diff --git a/.github/workflows/ci-build.yml b/.github/workflows/ci-build.yml index b0a7b00..5223e3b 100644 --- a/.github/workflows/ci-build.yml +++ b/.github/workflows/ci-build.yml @@ -27,6 +27,18 @@ jobs: with: dotnet-version: 3.1.x + - name: Install .NET 5 + uses: actions/setup-dotnet@v1 + with: + dotnet-version: 5.0.x + + - name: Add MSBuild to PATH + uses: glennawatson/setup-msbuild@v1.0.3 + + - name: Update VS2019 + shell: powershell + run: Start-Process -Wait -PassThru -FilePath "C:\Program Files (x86)\Microsoft Visual Studio\Installer\vs_installer.exe" -ArgumentList "update --passive --norestart --installpath ""C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise""" + - name: NBGV id: nbgv uses: dotnet/nbgv@master @@ -37,9 +49,6 @@ jobs: run: dotnet restore working-directory: src - - name: Add MSBuild to PATH - uses: microsoft/setup-msbuild@v1 - - name: Build run: msbuild /t:build,pack /maxcpucount /p:NoPackageAnalysis=true /verbosity:minimal /p:Configuration=${{ env.configuration }} working-directory: src diff --git a/src/Directory.build.props b/src/Directory.build.props index 1d87465..164bb6c 100644 --- a/src/Directory.build.props +++ b/src/Directory.build.props @@ -13,7 +13,7 @@ https://github.com/reactiveui/Pharmacist https://github.com/reactiveui/styleguide/blob/master/logo_pharmacist/main.png?raw=true Produces from NuGet packages or reference assemblies System.Reactive Observables for all events within the specified target. - mvvm;reactiveui;rx;reactive extensions;observable;events;frp;xamarin;android;ios;mac;forms;monodroid;monotouch;xamarin.android;xamarin.ios;xamarin.forms;xamarin.mac;xamarin.tvos;wpf;net;netstandard;net461;uwp;tizen;generator + mvvm;reactiveui;rx;reactive extensions;observable;events;frp;xamarin;android;ios;mac;forms;monodroid;monotouch;xamarin.android;xamarin.ios;xamarin.forms;xamarin.mac;xamarin.tvos;wpf;net;netstandard;net472;uwp;tizen;generator https://github.com/reactiveui/Pharmacist/releases https://github.com/reactiveui/Pharmacist git @@ -31,7 +31,6 @@ Full - @@ -49,7 +48,7 @@ - + diff --git a/src/ICSharpCode.Decompiler/DecompilerException.cs b/src/ICSharpCode.Decompiler/DecompilerException.cs new file mode 100644 index 0000000..a121751 --- /dev/null +++ b/src/ICSharpCode.Decompiler/DecompilerException.cs @@ -0,0 +1,206 @@ +// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Diagnostics; +using System.IO; +using System.Reflection; +using System.Reflection.Metadata.Ecma335; +using System.Runtime.InteropServices; +using System.Runtime.Serialization; +using System.Security; +using System.Text; + +using ICSharpCode.Decompiler.Metadata; +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler +{ + /// + /// Description of DecompilerException. + /// + public class DecompilerException : Exception, ISerializable + { + public string AssemblyName => File.Name; + + public string FileName => File.FileName; + + public IEntity DecompiledEntity { get; } + public IModule Module { get; } + public PEFile File { get; } + + public DecompilerException(MetadataModule module, IEntity decompiledEntity, + Exception innerException, string message = null) + : base(message ?? GetDefaultMessage(decompiledEntity), innerException) + { + this.File = module.PEFile; + this.Module = module; + this.DecompiledEntity = decompiledEntity; + } + + public DecompilerException(PEFile file, string message, Exception innerException) + : base(message, innerException) + { + this.File = file; + } + + static string GetDefaultMessage(IEntity entity) + { + if (entity == null) + return "Error decompiling"; + return $"Error decompiling @{MetadataTokens.GetToken(entity.MetadataToken):X8} {entity.FullName}"; + } + + // This constructor is needed for serialization. + protected DecompilerException(SerializationInfo info, StreamingContext context) : base(info, context) + { + } + + public override string StackTrace => GetStackTrace(this); + + public override string ToString() => ToString(this); + + string ToString(Exception exception) + { + if (exception == null) + throw new ArgumentNullException(nameof(exception)); + var exceptionType = GetTypeName(exception); + var stacktrace = GetStackTrace(exception); + while (exception.InnerException != null) + { + exception = exception.InnerException; + + stacktrace = GetStackTrace(exception) + Environment.NewLine + + "-- continuing with outer exception (" + exceptionType + ") --" + Environment.NewLine + + stacktrace; + exceptionType = GetTypeName(exception); + } + return this.Message + Environment.NewLine + + $"in assembly \"{this.FileName}\"" + Environment.NewLine + + " ---> " + exceptionType + ": " + exception.Message + Environment.NewLine + + stacktrace; + } + + static string GetTypeName(Exception exception) + { + var type = exception.GetType().FullName; + if (exception is ExternalException || exception is IOException) + return type + " (" + Marshal.GetHRForException(exception).ToString("x8") + ")"; + else + return type; + } + + static string GetStackTrace(Exception exception) + { + // Output stacktrace in custom format (very similar to Exception.StackTrace + // property on English systems). + // Include filenames where available, but no paths. + var stackTrace = new StackTrace(exception, true); + var b = new StringBuilder(); + for (var i = 0; i < stackTrace.FrameCount; i++) + { + var frame = stackTrace.GetFrame(i); + var method = frame.GetMethod(); + if (method == null) + continue; + + if (b.Length > 0) + b.AppendLine(); + + b.Append(" at "); + var declaringType = method.DeclaringType; + if (declaringType != null) + { + b.Append(declaringType.FullName.Replace('+', '.')); + b.Append('.'); + } + b.Append(method.Name); + // output type parameters, if any + if ((method is MethodInfo) && ((MethodInfo)method).IsGenericMethod) + { + var genericArguments = ((MethodInfo)method).GetGenericArguments(); + b.Append('['); + for (var j = 0; j < genericArguments.Length; j++) + { + if (j > 0) + b.Append(','); + b.Append(genericArguments[j].Name); + } + b.Append(']'); + } + + // output parameters, if any + b.Append('('); + var parameters = method.GetParameters(); + for (var j = 0; j < parameters.Length; j++) + { + if (j > 0) + b.Append(", "); + if (parameters[j].ParameterType != null) + { + b.Append(parameters[j].ParameterType.Name); + } + else + { + b.Append('?'); + } + if (!string.IsNullOrEmpty(parameters[j].Name)) + { + b.Append(' '); + b.Append(parameters[j].Name); + } + } + b.Append(')'); + + // source location + if (frame.GetILOffset() >= 0) + { + string filename = null; + try + { + var fullpath = frame.GetFileName(); + if (fullpath != null) + filename = Path.GetFileName(fullpath); + } + catch (SecurityException) + { + // StackFrame.GetFileName requires PathDiscovery permission + } + catch (ArgumentException) + { + // Path.GetFileName might throw on paths with invalid chars + } + b.Append(" in "); + if (filename != null) + { + b.Append(filename); + b.Append(":line "); + b.Append(frame.GetFileLineNumber()); + } + else + { + b.Append("offset "); + b.Append(frame.GetILOffset()); + } + } + } + + return b.ToString(); + } + } +} \ No newline at end of file diff --git a/src/ICSharpCode.Decompiler/DecompilerNuGetPackageIcon.png b/src/ICSharpCode.Decompiler/DecompilerNuGetPackageIcon.png new file mode 100644 index 0000000..cf73b30 --- /dev/null +++ b/src/ICSharpCode.Decompiler/DecompilerNuGetPackageIcon.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9a405719968acc92a330412b4c1c8ebc8d2c30996c4027c6ba9035db2424bee6 +size 2454 diff --git a/src/ICSharpCode.Decompiler/DisassemblerHelpers.cs b/src/ICSharpCode.Decompiler/DisassemblerHelpers.cs new file mode 100644 index 0000000..cebfab2 --- /dev/null +++ b/src/ICSharpCode.Decompiler/DisassemblerHelpers.cs @@ -0,0 +1,344 @@ +// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Linq; +using System.Reflection.Metadata; +using System.Text; + +using ICSharpCode.Decompiler.Metadata; + +using SRM = System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler.Disassembler +{ + public enum ILNameSyntax + { + /// + /// class/valuetype + TypeName (built-in types use keyword syntax) + /// + Signature, + /// + /// Like signature, but always refers to type parameters using their position + /// + SignatureNoNamedTypeParameters, + /// + /// [assembly]Full.Type.Name (even for built-in types) + /// + TypeName, + /// + /// Name (but built-in types use keyword syntax) + /// + ShortTypeName + } + + public static class DisassemblerHelpers + { + public static string OffsetToString(int offset) + { + return string.Format("IL_{0:x4}", offset); + } + + public static string OffsetToString(long offset) + { + return string.Format("IL_{0:x4}", offset); + } + + public static void WriteOffsetReference(ITextOutput writer, int? offset) + { + if (offset == null) + writer.Write("null"); + else + writer.WriteLocalReference(OffsetToString(offset.Value), offset); + } + + static string ToInvariantCultureString(object value) + { + var convertible = value as IConvertible; + return (null != convertible) + ? convertible.ToString(System.Globalization.CultureInfo.InvariantCulture) + : value.ToString(); + } + + static bool IsValidIdentifierCharacter(char c) + { + return c == '_' || c == '$' || c == '@' || c == '?' || c == '`'; + } + + static bool IsValidIdentifier(string identifier) + { + if (string.IsNullOrEmpty(identifier)) + return false; + if (!(char.IsLetter(identifier[0]) || IsValidIdentifierCharacter(identifier[0]))) + { + // As a special case, .ctor and .cctor are valid despite starting with a dot + return identifier == ".ctor" || identifier == ".cctor"; + } + for (var i = 1; i < identifier.Length; i++) + { + if (!(char.IsLetterOrDigit(identifier[i]) || IsValidIdentifierCharacter(identifier[i]) || identifier[i] == '.')) + return false; + } + return true; + } + + public static string Escape(string identifier) + { + if (IsValidIdentifier(identifier) && !Metadata.ILOpCodeExtensions.ILKeywords.Contains(identifier)) + { + return identifier; + } + else + { + // The ECMA specification says that ' inside SQString should be ecaped using an octal escape sequence, + // but we follow Microsoft's ILDasm and use \'. + return "'" + EscapeString(identifier).Replace("'", "\\'") + "'"; + } + } + + public static void WriteParameterReference(ITextOutput writer, MetadataReader metadata, MethodDefinitionHandle handle, int sequence) + { + var methodDefinition = metadata.GetMethodDefinition(handle); + var signature = methodDefinition.DecodeSignature(new FullTypeNameSignatureDecoder(metadata), default); + var parameters = methodDefinition.GetParameters().Select(p => metadata.GetParameter(p)).ToArray(); + var signatureHeader = signature.Header; + var index = sequence; + if (signatureHeader.IsInstance && signature.ParameterTypes.Length == parameters.Length) + { + index--; + } + if (index < 0 || index >= parameters.Length) + { + writer.WriteLocalReference(sequence.ToString(), "param_" + index); + } + else + { + var param = parameters[index]; + if (param.Name.IsNil) + { + writer.WriteLocalReference(sequence.ToString(), "param_" + index); + } + else + { + writer.WriteLocalReference(Escape(metadata.GetString(param.Name)), "param_" + index); + } + } + } + + public static void WriteVariableReference(ITextOutput writer, MetadataReader metadata, MethodDefinitionHandle handle, int index) + { + writer.WriteLocalReference(index.ToString(), "loc_" + index); + } + + public static void WriteOperand(ITextOutput writer, object operand) + { + if (operand == null) + throw new ArgumentNullException(nameof(operand)); + + var s = operand as string; + if (s != null) + { + WriteOperand(writer, s); + } + else if (operand is char) + { + writer.Write(((int)(char)operand).ToString()); + } + else if (operand is float) + { + WriteOperand(writer, (float)operand); + } + else if (operand is double) + { + WriteOperand(writer, (double)operand); + } + else if (operand is bool) + { + writer.Write((bool)operand ? "true" : "false"); + } + else + { + s = ToInvariantCultureString(operand); + writer.Write(s); + } + } + + public static void WriteOperand(ITextOutput writer, long val) + { + writer.Write(ToInvariantCultureString(val)); + } + + public static void WriteOperand(ITextOutput writer, float val) + { + if (val == 0) + { + if (1 / val == float.NegativeInfinity) + { + // negative zero is a special case + writer.Write('-'); + } + writer.Write("0.0"); + } + else if (float.IsInfinity(val) || float.IsNaN(val)) + { + var data = BitConverter.GetBytes(val); + writer.Write('('); + for (var i = 0; i < data.Length; i++) + { + if (i > 0) + writer.Write(' '); + writer.Write(data[i].ToString("X2")); + } + writer.Write(')'); + } + else + { + writer.Write(val.ToString("R", System.Globalization.CultureInfo.InvariantCulture)); + } + } + + public static void WriteOperand(ITextOutput writer, double val) + { + if (val == 0) + { + if (1 / val == double.NegativeInfinity) + { + // negative zero is a special case + writer.Write('-'); + } + writer.Write("0.0"); + } + else if (double.IsInfinity(val) || double.IsNaN(val)) + { + var data = BitConverter.GetBytes(val); + writer.Write('('); + for (var i = 0; i < data.Length; i++) + { + if (i > 0) + writer.Write(' '); + writer.Write(data[i].ToString("X2")); + } + writer.Write(')'); + } + else + { + writer.Write(val.ToString("R", System.Globalization.CultureInfo.InvariantCulture)); + } + } + + public static void WriteOperand(ITextOutput writer, string operand) + { + writer.Write('"'); + writer.Write(EscapeString(operand)); + writer.Write('"'); + } + + public static string EscapeString(string str) + { + var sb = new StringBuilder(); + foreach (var ch in str) + { + switch (ch) + { + case '"': + sb.Append("\\\""); + break; + case '\\': + sb.Append("\\\\"); + break; + case '\0': + sb.Append("\\0"); + break; + case '\a': + sb.Append("\\a"); + break; + case '\b': + sb.Append("\\b"); + break; + case '\f': + sb.Append("\\f"); + break; + case '\n': + sb.Append("\\n"); + break; + case '\r': + sb.Append("\\r"); + break; + case '\t': + sb.Append("\\t"); + break; + case '\v': + sb.Append("\\v"); + break; + default: + // print control characters and uncommon white spaces as numbers + if (char.IsControl(ch) || char.IsSurrogate(ch) || (char.IsWhiteSpace(ch) && ch != ' ')) + { + sb.Append("\\u" + ((int)ch).ToString("x4")); + } + else + { + sb.Append(ch); + } + break; + } + } + return sb.ToString(); + } + public static string PrimitiveTypeName(string fullName) + { + switch (fullName) + { + case "System.SByte": + return "int8"; + case "System.Int16": + return "int16"; + case "System.Int32": + return "int32"; + case "System.Int64": + return "int64"; + case "System.Byte": + return "uint8"; + case "System.UInt16": + return "uint16"; + case "System.UInt32": + return "uint32"; + case "System.UInt64": + return "uint64"; + case "System.Single": + return "float32"; + case "System.Double": + return "float64"; + case "System.Void": + return "void"; + case "System.Boolean": + return "bool"; + case "System.String": + return "string"; + case "System.Char": + return "char"; + case "System.Object": + return "object"; + case "System.IntPtr": + return "native int"; + default: + return null; + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Documentation/GetPotentiallyNestedClassTypeReference.cs b/src/ICSharpCode.Decompiler/Documentation/GetPotentiallyNestedClassTypeReference.cs new file mode 100644 index 0000000..3a79923 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Documentation/GetPotentiallyNestedClassTypeReference.cs @@ -0,0 +1,124 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Linq; +using System.Reflection.Metadata; + +using ICSharpCode.Decompiler.Metadata; +using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.Documentation +{ + /// + /// A type reference of the form 'Some.Namespace.TopLevelType.NestedType`n'. + /// We do not know the boundary between namespace name and top level type, so we have to try + /// all possibilities. + /// The type parameter count only applies to the innermost type, all outer types must be non-generic. + /// + [Serializable] + public class GetPotentiallyNestedClassTypeReference : ITypeReference + { + readonly string typeName; + readonly int typeParameterCount; + + public GetPotentiallyNestedClassTypeReference(string typeName, int typeParameterCount) + { + this.typeName = typeName; + this.typeParameterCount = typeParameterCount; + } + + public IType Resolve(ITypeResolveContext context) + { + var parts = typeName.Split('.'); + var assemblies = new[] { context.CurrentModule }.Concat(context.Compilation.Modules); + for (var i = parts.Length - 1; i >= 0; i--) + { + var ns = string.Join(".", parts, 0, i); + var name = parts[i]; + var topLevelTPC = (i == parts.Length - 1 ? typeParameterCount : 0); + foreach (var asm in assemblies) + { + if (asm == null) + continue; + var typeDef = asm.GetTypeDefinition(new TopLevelTypeName(ns, name, topLevelTPC)); + for (var j = i + 1; j < parts.Length && typeDef != null; j++) + { + var tpc = (j == parts.Length - 1 ? typeParameterCount : 0); + typeDef = typeDef.NestedTypes.FirstOrDefault(n => n.Name == parts[j] && n.TypeParameterCount == tpc); + } + if (typeDef != null) + return typeDef; + } + } + var idx = typeName.LastIndexOf('.'); + if (idx < 0) + return new UnknownType("", typeName, typeParameterCount); + // give back a guessed namespace/type name + return new UnknownType(typeName.Substring(0, idx), typeName.Substring(idx + 1), typeParameterCount); + } + + /// + /// Resolves the type reference within the context of the given PE file. + /// + /// Either TypeDefinitionHandle, if the type is defined in the module or ExportedTypeHandle, + /// if the module contains a type forwarder. Returns a nil handle, if the type was not found. + public EntityHandle ResolveInPEFile(PEFile module) + { + var parts = typeName.Split('.'); + for (var i = parts.Length - 1; i >= 0; i--) + { + var ns = string.Join(".", parts, 0, i); + var name = parts[i]; + var topLevelTPC = (i == parts.Length - 1 ? typeParameterCount : 0); + var topLevelName = new TopLevelTypeName(ns, name, topLevelTPC); + var typeHandle = module.GetTypeDefinition(topLevelName); + + for (var j = i + 1; j < parts.Length && !typeHandle.IsNil; j++) + { + var tpc = (j == parts.Length - 1 ? typeParameterCount : 0); + var typeDef = module.Metadata.GetTypeDefinition(typeHandle); + var lookupName = parts[j] + (tpc > 0 ? "`" + tpc : ""); + typeHandle = typeDef.GetNestedTypes().FirstOrDefault(n => IsEqualShortName(n, module.Metadata, lookupName)); + } + + if (!typeHandle.IsNil) + return typeHandle; + FullTypeName typeName = topLevelName; + for (var j = i + 1; j < parts.Length; j++) + { + var tpc = (j == parts.Length - 1 ? typeParameterCount : 0); + typeName = typeName.NestedType(parts[j], tpc); + } + + var exportedType = module.GetTypeForwarder(typeName); + if (!exportedType.IsNil) + return exportedType; + } + + return default; + + bool IsEqualShortName(TypeDefinitionHandle h, MetadataReader metadata, string name) + { + var nestedType = metadata.GetTypeDefinition(h); + return metadata.StringComparer.Equals(nestedType.Name, name); + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Documentation/IdStringMemberReference.cs b/src/ICSharpCode.Decompiler/Documentation/IdStringMemberReference.cs new file mode 100644 index 0000000..300f94a --- /dev/null +++ b/src/ICSharpCode.Decompiler/Documentation/IdStringMemberReference.cs @@ -0,0 +1,75 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Documentation +{ + [Serializable] + class IdStringMemberReference : IMemberReference + { + readonly ITypeReference declaringTypeReference; + readonly char memberType; + readonly string memberIdString; + + public IdStringMemberReference(ITypeReference declaringTypeReference, char memberType, string memberIdString) + { + this.declaringTypeReference = declaringTypeReference; + this.memberType = memberType; + this.memberIdString = memberIdString; + } + + bool CanMatch(IMember member) + { + switch (member.SymbolKind) + { + case SymbolKind.Field: + return memberType == 'F'; + case SymbolKind.Property: + case SymbolKind.Indexer: + return memberType == 'P'; + case SymbolKind.Event: + return memberType == 'E'; + case SymbolKind.Method: + case SymbolKind.Operator: + case SymbolKind.Constructor: + case SymbolKind.Destructor: + return memberType == 'M'; + default: + throw new NotSupportedException(member.SymbolKind.ToString()); + } + } + + public ITypeReference DeclaringTypeReference { + get { return declaringTypeReference; } + } + + public IMember Resolve(ITypeResolveContext context) + { + var declaringType = declaringTypeReference.Resolve(context); + foreach (var member in declaringType.GetMembers(CanMatch, GetMemberOptions.IgnoreInheritedMembers)) + { + if (IdStringProvider.GetIdString(member) == memberIdString) + return member; + } + return null; + } + } +} diff --git a/src/ICSharpCode.Decompiler/Documentation/IdStringProvider.cs b/src/ICSharpCode.Decompiler/Documentation/IdStringProvider.cs new file mode 100644 index 0000000..22ddf5b --- /dev/null +++ b/src/ICSharpCode.Decompiler/Documentation/IdStringProvider.cs @@ -0,0 +1,433 @@ +// Copyright (c) 2010-2018 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.Documentation +{ + /// + /// Provides ID strings for entities. (C# 4.0 spec, §A.3.1) + /// ID strings are used to identify members in XML documentation files. + /// + public static class IdStringProvider + { + #region GetIdString + /// + /// Gets the ID string (C# 4.0 spec, §A.3.1) for the specified entity. + /// + public static string GetIdString(this IEntity entity) + { + var b = new StringBuilder(); + switch (entity.SymbolKind) + { + case SymbolKind.TypeDefinition: + b.Append("T:"); + AppendTypeName(b, (ITypeDefinition)entity, false); + return b.ToString(); + case SymbolKind.Field: + b.Append("F:"); + break; + case SymbolKind.Property: + case SymbolKind.Indexer: + b.Append("P:"); + break; + case SymbolKind.Event: + b.Append("E:"); + break; + default: + b.Append("M:"); + break; + } + var member = (IMember)entity; + if (member.DeclaringType != null) + { + AppendTypeName(b, member.DeclaringType, false); + b.Append('.'); + } + if (member.IsExplicitInterfaceImplementation && member.Name.IndexOf('.') < 0 && member.ExplicitlyImplementedInterfaceMembers.Count() == 1) + { + AppendTypeName(b, member.ExplicitlyImplementedInterfaceMembers.First().DeclaringType, true); + b.Append('#'); + } + b.Append(member.Name.Replace('.', '#').Replace('<', '{').Replace('>', '}')); + var method = member as IMethod; + if (method != null && method.TypeParameters.Count > 0) + { + b.Append("``"); + b.Append(method.TypeParameters.Count); + } + var parameterizedMember = member as IParameterizedMember; + if (parameterizedMember != null && parameterizedMember.Parameters.Count > 0) + { + b.Append('('); + var parameters = parameterizedMember.Parameters; + for (var i = 0; i < parameters.Count; i++) + { + if (i > 0) + b.Append(','); + AppendTypeName(b, parameters[i].Type, false); + } + b.Append(')'); + } + if (member.SymbolKind == SymbolKind.Operator && (member.Name == "op_Implicit" || member.Name == "op_Explicit")) + { + b.Append('~'); + AppendTypeName(b, member.ReturnType, false); + } + return b.ToString(); + } + #endregion + + #region GetTypeName + public static string GetTypeName(IType type) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + var b = new StringBuilder(); + AppendTypeName(b, type, false); + return b.ToString(); + } + + static void AppendTypeName(StringBuilder b, IType type, bool explicitInterfaceImpl) + { + switch (type.Kind) + { + case TypeKind.Dynamic: + b.Append(explicitInterfaceImpl ? "System#Object" : "System.Object"); + break; + case TypeKind.TypeParameter: + var tp = (ITypeParameter)type; + if (explicitInterfaceImpl) + { + b.Append(tp.Name); + } + else + { + b.Append('`'); + if (tp.OwnerType == SymbolKind.Method) + b.Append('`'); + b.Append(tp.Index); + } + break; + case TypeKind.Array: + var array = (ArrayType)type; + AppendTypeName(b, array.ElementType, explicitInterfaceImpl); + b.Append('['); + if (array.Dimensions > 1) + { + for (var i = 0; i < array.Dimensions; i++) + { + if (i > 0) + b.Append(explicitInterfaceImpl ? '@' : ','); + if (!explicitInterfaceImpl) + b.Append("0:"); + } + } + b.Append(']'); + break; + case TypeKind.Pointer: + AppendTypeName(b, ((PointerType)type).ElementType, explicitInterfaceImpl); + b.Append('*'); + break; + case TypeKind.ByReference: + AppendTypeName(b, ((ByReferenceType)type).ElementType, explicitInterfaceImpl); + b.Append('@'); + break; + default: + var declType = type.DeclaringType; + if (declType != null) + { + AppendTypeName(b, declType, explicitInterfaceImpl); + b.Append(explicitInterfaceImpl ? '#' : '.'); + b.Append(type.Name); + AppendTypeParameters(b, type, declType.TypeParameterCount, explicitInterfaceImpl); + } + else + { + if (explicitInterfaceImpl) + b.Append(type.FullName.Replace('.', '#')); + else + b.Append(type.FullName); + AppendTypeParameters(b, type, 0, explicitInterfaceImpl); + } + break; + } + } + + static void AppendTypeParameters(StringBuilder b, IType type, int outerTypeParameterCount, bool explicitInterfaceImpl) + { + var tpc = type.TypeParameterCount - outerTypeParameterCount; + if (tpc > 0) + { + var pt = type as ParameterizedType; + if (pt != null) + { + b.Append('{'); + var ta = pt.TypeArguments; + for (var i = outerTypeParameterCount; i < ta.Count; i++) + { + if (i > outerTypeParameterCount) + b.Append(explicitInterfaceImpl ? '@' : ','); + AppendTypeName(b, ta[i], explicitInterfaceImpl); + } + b.Append('}'); + } + else + { + b.Append('`'); + b.Append(tpc); + } + } + } + #endregion + + #region ParseMemberName + /// + /// Parse the ID string into a member reference. + /// + /// The ID string representing the member (with "M:", "F:", "P:" or "E:" prefix). + /// A member reference that represents the ID string. + /// The syntax of the ID string is invalid + /// + /// The member reference will look in first, + /// and if the member is not found there, + /// it will look in all other assemblies of the compilation. + /// + public static IMemberReference ParseMemberIdString(string memberIdString) + { + if (memberIdString == null) + throw new ArgumentNullException(nameof(memberIdString)); + if (memberIdString.Length < 2 || memberIdString[1] != ':') + throw new ReflectionNameParseException(0, "Missing type tag"); + var typeChar = memberIdString[0]; + var parenPos = memberIdString.IndexOf('('); + if (parenPos < 0) + parenPos = memberIdString.LastIndexOf('~'); + if (parenPos < 0) + parenPos = memberIdString.Length; + var dotPos = memberIdString.LastIndexOf('.', parenPos - 1); + if (dotPos < 0) + throw new ReflectionNameParseException(0, "Could not find '.' separating type name from member name"); + var typeName = memberIdString.Substring(0, dotPos); + var pos = 2; + var typeReference = ParseTypeName(typeName, ref pos); + if (pos != typeName.Length) + throw new ReflectionNameParseException(pos, "Expected end of type name"); + // string memberName = memberIDString.Substring(dotPos + 1, parenPos - (dotPos + 1)); + // pos = memberName.LastIndexOf("``"); + // if (pos > 0) + // memberName = memberName.Substring(0, pos); + // memberName = memberName.Replace('#', '.'); + return new IdStringMemberReference(typeReference, typeChar, memberIdString); + } + #endregion + + #region ParseTypeName + /// + /// Parse the ID string type name into a type reference. + /// + /// The ID string representing the type (the "T:" prefix is optional). + /// A type reference that represents the ID string. + /// The syntax of the ID string is invalid + /// + /// + /// The type reference will look in first, + /// and if the type is not found there, + /// it will look in all other assemblies of the compilation. + /// + /// + /// If the type is open (contains type parameters '`0' or '``0'), + /// an with the appropriate CurrentTypeDefinition/CurrentMember is required + /// to resolve the reference to the ITypeParameter. + /// + /// + public static ITypeReference ParseTypeName(string typeName) + { + if (typeName == null) + throw new ArgumentNullException(nameof(typeName)); + var pos = 0; + if (typeName.StartsWith("T:", StringComparison.Ordinal)) + pos = 2; + var r = ParseTypeName(typeName, ref pos); + if (pos < typeName.Length) + throw new ReflectionNameParseException(pos, "Expected end of type name"); + return r; + } + + static bool IsIDStringSpecialCharacter(char c) + { + switch (c) + { + case ':': + case '{': + case '}': + case '[': + case ']': + case '(': + case ')': + case '`': + case '*': + case '@': + case ',': + return true; + default: + return false; + } + } + + static ITypeReference ParseTypeName(string typeName, ref int pos) + { + var reflectionTypeName = typeName; + if (pos == typeName.Length) + throw new ReflectionNameParseException(pos, "Unexpected end"); + ITypeReference result; + if (reflectionTypeName[pos] == '`') + { + // type parameter reference + pos++; + if (pos == reflectionTypeName.Length) + throw new ReflectionNameParseException(pos, "Unexpected end"); + if (reflectionTypeName[pos] == '`') + { + // method type parameter reference + pos++; + var index = ReflectionHelper.ReadTypeParameterCount(reflectionTypeName, ref pos); + result = TypeParameterReference.Create(SymbolKind.Method, index); + } + else + { + // class type parameter reference + var index = ReflectionHelper.ReadTypeParameterCount(reflectionTypeName, ref pos); + result = TypeParameterReference.Create(SymbolKind.TypeDefinition, index); + } + } + else + { + // not a type parameter reference: read the actual type name + var typeArguments = new List(); + var typeNameWithoutSuffix = ReadTypeName(typeName, ref pos, true, out var typeParameterCount, typeArguments); + result = new GetPotentiallyNestedClassTypeReference(typeNameWithoutSuffix, typeParameterCount); + while (pos < typeName.Length && typeName[pos] == '.') + { + pos++; + var nestedTypeName = ReadTypeName(typeName, ref pos, false, out typeParameterCount, typeArguments); + result = new NestedTypeReference(result, nestedTypeName, typeParameterCount); + } + if (typeArguments.Count > 0) + { + result = new ParameterizedTypeReference(result, typeArguments); + } + } + while (pos < typeName.Length) + { + switch (typeName[pos]) + { + case '[': + var dimensions = 1; + do + { + pos++; + if (pos == typeName.Length) + throw new ReflectionNameParseException(pos, "Unexpected end"); + if (typeName[pos] == ',') + dimensions++; + } while (typeName[pos] != ']'); + result = new ArrayTypeReference(result, dimensions); + break; + case '*': + result = new PointerTypeReference(result); + break; + case '@': + result = new ByReferenceTypeReference(result); + break; + default: + return result; + } + pos++; + } + return result; + } + + static string ReadTypeName(string typeName, ref int pos, bool allowDottedName, out int typeParameterCount, List typeArguments) + { + var startPos = pos; + // skip the simple name portion: + while (pos < typeName.Length && !IsIDStringSpecialCharacter(typeName[pos]) && (allowDottedName || typeName[pos] != '.')) + pos++; + if (pos == startPos) + throw new ReflectionNameParseException(pos, "Expected type name"); + var shortTypeName = typeName.Substring(startPos, pos - startPos); + // read type arguments: + typeParameterCount = 0; + if (pos < typeName.Length && typeName[pos] == '`') + { + // unbound generic type + pos++; + typeParameterCount = ReflectionHelper.ReadTypeParameterCount(typeName, ref pos); + } + else if (pos < typeName.Length && typeName[pos] == '{') + { + // bound generic type + do + { + pos++; + typeArguments.Add(ParseTypeName(typeName, ref pos)); + typeParameterCount++; + if (pos == typeName.Length) + throw new ReflectionNameParseException(pos, "Unexpected end"); + } while (typeName[pos] == ','); + if (typeName[pos] != '}') + throw new ReflectionNameParseException(pos, "Expected '}'"); + pos++; + } + return shortTypeName; + } + #endregion + + #region FindEntity + /// + /// Finds the entity in the given type resolve context. + /// + /// ID string of the entity. + /// Type resolve context + /// Returns the entity, or null if it is not found. + /// The syntax of the ID string is invalid + public static IEntity FindEntity(string idString, ITypeResolveContext context) + { + if (idString == null) + throw new ArgumentNullException(nameof(idString)); + if (context == null) + throw new ArgumentNullException(nameof(context)); + if (idString.StartsWith("T:", StringComparison.Ordinal)) + { + return ParseTypeName(idString.Substring(2)).Resolve(context).GetDefinition(); + } + else + { + return ParseMemberIdString(idString).Resolve(context); + } + } + #endregion + } +} diff --git a/src/ICSharpCode.Decompiler/Documentation/XmlDocLoader.cs b/src/ICSharpCode.Decompiler/Documentation/XmlDocLoader.cs new file mode 100644 index 0000000..248b279 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Documentation/XmlDocLoader.cs @@ -0,0 +1,146 @@ +// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Diagnostics; +using System.IO; +using System.Runtime.CompilerServices; + +using ICSharpCode.Decompiler.Metadata; + +namespace ICSharpCode.Decompiler.Documentation +{ + /// + /// Helps finding and loading .xml documentation. + /// + public static class XmlDocLoader + { + static readonly Lazy mscorlibDocumentation = new Lazy(LoadMscorlibDocumentation); + static readonly ConditionalWeakTable cache = new ConditionalWeakTable(); + + static XmlDocumentationProvider LoadMscorlibDocumentation() + { + var xmlDocFile = FindXmlDocumentation("mscorlib.dll", TargetRuntime.Net_4_0) + ?? FindXmlDocumentation("mscorlib.dll", TargetRuntime.Net_2_0); + if (xmlDocFile != null) + return new XmlDocumentationProvider(xmlDocFile); + else + return null; + } + + public static XmlDocumentationProvider MscorlibDocumentation { + get { return mscorlibDocumentation.Value; } + } + + public static XmlDocumentationProvider LoadDocumentation(PEFile module) + { + if (module == null) + throw new ArgumentNullException(nameof(module)); + lock (cache) + { + if (!cache.TryGetValue(module, out var xmlDoc)) + { + var xmlDocFile = LookupLocalizedXmlDoc(module.FileName); + if (xmlDocFile == null) + { + xmlDocFile = FindXmlDocumentation(Path.GetFileName(module.FileName), module.GetRuntime()); + } + if (xmlDocFile != null) + { + xmlDoc = new XmlDocumentationProvider(xmlDocFile); + cache.Add(module, xmlDoc); + } + else + { + cache.Add(module, null); // add missing documentation files as well + xmlDoc = null; + } + } + return xmlDoc; + } + } + + static readonly string referenceAssembliesPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), @"Reference Assemblies\Microsoft\\Framework"); + static readonly string frameworkPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Windows), @"Microsoft.NET\Framework"); + + static string FindXmlDocumentation(string assemblyFileName, TargetRuntime runtime) + { + string fileName; + switch (runtime) + { + case TargetRuntime.Net_1_0: + fileName = LookupLocalizedXmlDoc(Path.Combine(frameworkPath, "v1.0.3705", assemblyFileName)); + break; + case TargetRuntime.Net_1_1: + fileName = LookupLocalizedXmlDoc(Path.Combine(frameworkPath, "v1.1.4322", assemblyFileName)); + break; + case TargetRuntime.Net_2_0: + fileName = LookupLocalizedXmlDoc(Path.Combine(frameworkPath, "v2.0.50727", assemblyFileName)) + ?? LookupLocalizedXmlDoc(Path.Combine(referenceAssembliesPath, "v3.5")) + ?? LookupLocalizedXmlDoc(Path.Combine(referenceAssembliesPath, "v3.0")) + ?? LookupLocalizedXmlDoc(Path.Combine(referenceAssembliesPath, @".NETFramework\v3.5\Profile\Client")); + break; + case TargetRuntime.Net_4_0: + default: + fileName = LookupLocalizedXmlDoc(Path.Combine(referenceAssembliesPath, @".NETFramework\v4.0", assemblyFileName)) + ?? LookupLocalizedXmlDoc(Path.Combine(frameworkPath, "v4.0.30319", assemblyFileName)); + break; + } + return fileName; + } + + static string LookupLocalizedXmlDoc(string fileName) + { + if (string.IsNullOrEmpty(fileName)) + return null; + + var xmlFileName = Path.ChangeExtension(fileName, ".xml"); + var currentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName; + var localizedXmlDocFile = GetLocalizedName(xmlFileName, currentCulture); + + Debug.WriteLine("Try find XMLDoc @" + localizedXmlDocFile); + if (File.Exists(localizedXmlDocFile)) + { + return localizedXmlDocFile; + } + Debug.WriteLine("Try find XMLDoc @" + xmlFileName); + if (File.Exists(xmlFileName)) + { + return xmlFileName; + } + if (currentCulture != "en") + { + var englishXmlDocFile = GetLocalizedName(xmlFileName, "en"); + Debug.WriteLine("Try find XMLDoc @" + englishXmlDocFile); + if (File.Exists(englishXmlDocFile)) + { + return englishXmlDocFile; + } + } + return null; + } + + static string GetLocalizedName(string fileName, string language) + { + var localizedXmlDocFile = Path.GetDirectoryName(fileName); + localizedXmlDocFile = Path.Combine(localizedXmlDocFile, language); + localizedXmlDocFile = Path.Combine(localizedXmlDocFile, Path.GetFileName(fileName)); + return localizedXmlDocFile; + } + } +} diff --git a/src/ICSharpCode.Decompiler/Documentation/XmlDocumentationElement.cs b/src/ICSharpCode.Decompiler/Documentation/XmlDocumentationElement.cs new file mode 100644 index 0000000..d8b5c7b --- /dev/null +++ b/src/ICSharpCode.Decompiler/Documentation/XmlDocumentationElement.cs @@ -0,0 +1,267 @@ +// Copyright (c) 2009-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading; +using System.Xml.Linq; + +using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.Documentation +{ + /// + /// Represents an element in the XML documentation. + /// Any occurrences of "<inheritdoc/>" are replaced with the inherited documentation. + /// + public class XmlDocumentationElement + { + static XmlDocumentationElement Create(string documentationComment, IEntity declaringEntity) + { + return new XmlDocumentationElement(XElement.Parse(documentationComment), declaringEntity, null); + } + + readonly XElement element; + readonly IEntity declaringEntity; + readonly Func crefResolver; + volatile string textContent; + + /// + /// Inheritance level; used to prevent cyclic doc inheritance. + /// + int nestingLevel; + + /// + /// Creates a new documentation element. + /// + public XmlDocumentationElement(XElement element, IEntity declaringEntity, Func crefResolver) + { + if (element == null) + throw new ArgumentNullException(nameof(element)); + this.element = element; + this.declaringEntity = declaringEntity; + this.crefResolver = crefResolver; + } + + /// + /// Creates a new documentation element. + /// + public XmlDocumentationElement(string text, IEntity declaringEntity) + { + if (text == null) + throw new ArgumentNullException(nameof(text)); + this.declaringEntity = declaringEntity; + this.textContent = text; + } + + /// + /// Gets the entity on which this documentation was originally declared. + /// May return null. + /// + public IEntity DeclaringEntity { + get { return declaringEntity; } + } + + IEntity referencedEntity; + volatile bool referencedEntityInitialized; + + /// + /// Gets the entity referenced by the 'cref' attribute. + /// May return null. + /// + public IEntity ReferencedEntity { + get { + if (!referencedEntityInitialized) + { + var cref = GetAttribute("cref"); + try + { + if (!string.IsNullOrEmpty(cref) && crefResolver != null) + referencedEntity = crefResolver(cref); + } + catch + { + referencedEntity = null; + } + referencedEntityInitialized = true; + } + return referencedEntity; + } + } + + /// + /// Gets the element name. + /// + public string Name { + get { + return element != null ? element.Name.LocalName : string.Empty; + } + } + + /// + /// Gets the attribute value. + /// + public string GetAttribute(string name) + { + return element?.Attribute(name)?.Value; + } + + /// + /// Gets whether this is a pure text node. + /// + public bool IsTextNode { + get { return element == null; } + } + + /// + /// Gets the text content. + /// + public string TextContent { + get { + if (textContent == null) + { + var b = new StringBuilder(); + foreach (var child in this.Children) + b.Append(child.TextContent); + textContent = b.ToString(); + } + return textContent; + } + } + + IList children; + + /// + /// Gets the child elements. + /// + public IList Children { + get { + if (element == null) + return EmptyList.Instance; + return LazyInitializer.EnsureInitialized( + ref this.children, + () => CreateElements(element.Nodes(), declaringEntity, crefResolver, nestingLevel)); + } + } + + static readonly string[] doNotInheritIfAlreadyPresent = { + "example", "exclude", "filterpriority", "preliminary", "summary", + "remarks", "returns", "threadsafety", "value" + }; + + static List CreateElements(IEnumerable childObjects, IEntity declaringEntity, Func crefResolver, int nestingLevel) + { + var list = new List(); + foreach (var child in childObjects) + { + var childText = child as XText; + var childTag = child as XCData; + var childElement = child as XElement; + if (childText != null) + { + list.Add(new XmlDocumentationElement(childText.Value, declaringEntity)); + } + else if (childTag != null) + { + list.Add(new XmlDocumentationElement(childTag.Value, declaringEntity)); + } + else if (childElement != null) + { + if (nestingLevel < 5 && childElement.Name == "inheritdoc") + { + var cref = childElement.Attribute("cref").Value; + IEntity inheritedFrom = null; + string inheritedDocumentation = null; + if (cref != null) + { + inheritedFrom = crefResolver(cref); + if (inheritedFrom != null) + inheritedDocumentation = inheritedFrom.GetDocumentation(); + } + else + { + foreach (var baseMember in InheritanceHelper.GetBaseMembers((IMember)declaringEntity, includeImplementedInterfaces: true)) + { + inheritedDocumentation = baseMember.GetDocumentation(); + if (inheritedDocumentation != null) + { + inheritedFrom = baseMember; + break; + } + } + } + + if (inheritedDocumentation != null) + { + var doc = XDocument.Parse(inheritedDocumentation); + + // XPath filter not yet implemented + if (childElement.Parent == null && childElement.Attribute("select").Value == null) + { + // Inheriting documentation at the root level + var doNotInherit = new List(); + doNotInherit.Add("overloads"); + doNotInherit.AddRange(childObjects.OfType().Select(e => e.Name.LocalName).Intersect( + doNotInheritIfAlreadyPresent)); + + var inheritedChildren = doc.Nodes().Where( + inheritedObject => { + var inheritedElement = inheritedObject as XElement; + return !(inheritedElement != null && doNotInherit.Contains(inheritedElement.Name.LocalName)); + }); + + list.AddRange(CreateElements(inheritedChildren, inheritedFrom, crefResolver, nestingLevel + 1)); + } + } + } + else + { + list.Add(new XmlDocumentationElement(childElement, declaringEntity, crefResolver) { nestingLevel = nestingLevel }); + } + } + } + if (list.Count > 0 && list[0].IsTextNode) + { + if (string.IsNullOrWhiteSpace(list[0].textContent)) + list.RemoveAt(0); + else + list[0].textContent = list[0].textContent.TrimStart(); + } + if (list.Count > 0 && list[list.Count - 1].IsTextNode) + { + if (string.IsNullOrWhiteSpace(list[list.Count - 1].textContent)) + list.RemoveAt(list.Count - 1); + else + list[list.Count - 1].textContent = list[list.Count - 1].textContent.TrimEnd(); + } + return list; + } + + /// + public override string ToString() + { + if (element != null) + return "<" + element.Name + ">"; + else + return this.TextContent; + } + } +} diff --git a/src/ICSharpCode.Decompiler/Documentation/XmlDocumentationProvider.cs b/src/ICSharpCode.Decompiler/Documentation/XmlDocumentationProvider.cs new file mode 100644 index 0000000..dca680a --- /dev/null +++ b/src/ICSharpCode.Decompiler/Documentation/XmlDocumentationProvider.cs @@ -0,0 +1,484 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Runtime.Serialization; +using System.Text; +using System.Xml; + +using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.Documentation +{ + /// + /// Provides XML documentation for type and member definitions in source code. + /// + public interface IDocumentationProvider + { + /// + /// Returns the XML documentation for the given . + /// May return null, if no documentation is present for the entity. + /// + /// is null. + string GetDocumentation(IEntity entity); + } + + /// + /// Provides documentation from an .xml file (as generated by the Microsoft C# compiler). + /// + /// + /// This class first creates an in-memory index of the .xml file, and then uses that to read only the requested members. + /// This way, we avoid keeping all the documentation in memory. + /// The .xml file is only opened when necessary, the file handle is not kept open all the time. + /// If the .xml file is changed, the index will automatically be recreated. + /// + [Serializable] + public class XmlDocumentationProvider : IDeserializationCallback, IDocumentationProvider + { + #region Cache + sealed class XmlDocumentationCache + { + readonly KeyValuePair[] entries; + int pos; + + public XmlDocumentationCache(int size = 50) + { + if (size <= 0) + throw new ArgumentOutOfRangeException(nameof(size), size, "Value must be positive"); + this.entries = new KeyValuePair[size]; + } + + internal bool TryGet(string key, out string value) + { + foreach (var pair in entries) + { + if (pair.Key == key) + { + value = pair.Value; + return true; + } + } + value = null; + return false; + } + + internal void Add(string key, string value) + { + entries[pos++] = new KeyValuePair(key, value); + if (pos == entries.Length) + pos = 0; + } + } + #endregion + + [Serializable] + struct IndexEntry : IComparable + { + /// + /// Hash code of the documentation tag + /// + internal readonly int HashCode; + + /// + /// Position in the .xml file where the documentation starts + /// + internal readonly int PositionInFile; + + internal IndexEntry(int hashCode, int positionInFile) + { + this.HashCode = hashCode; + this.PositionInFile = positionInFile; + } + + public int CompareTo(IndexEntry other) + { + return this.HashCode.CompareTo(other.HashCode); + } + } + + [NonSerialized] + XmlDocumentationCache cache = new XmlDocumentationCache(); + + readonly string fileName; + readonly Encoding encoding; + volatile IndexEntry[] index; // SORTED array of index entries + + #region Constructor / Redirection support + /// + /// Creates a new XmlDocumentationProvider. + /// + /// Name of the .xml file. + /// Error reading from XML file (or from redirected file) + /// Invalid XML file + public XmlDocumentationProvider(string fileName) + { + if (fileName == null) + throw new ArgumentNullException(nameof(fileName)); + + using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete)) + { + using (var xmlReader = new XmlTextReader(fs)) + { + xmlReader.XmlResolver = null; // no DTD resolving + xmlReader.MoveToContent(); + if (string.IsNullOrEmpty(xmlReader.GetAttribute("redirect"))) + { + this.fileName = fileName; + this.encoding = xmlReader.Encoding; + ReadXmlDoc(xmlReader); + } + else + { + var redirectionTarget = GetRedirectionTarget(fileName, xmlReader.GetAttribute("redirect")); + if (redirectionTarget != null) + { + Debug.WriteLine("XmlDoc " + fileName + " is redirecting to " + redirectionTarget); + using (var redirectedFs = new FileStream(redirectionTarget, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete)) + { + using (var redirectedXmlReader = new XmlTextReader(redirectedFs)) + { + redirectedXmlReader.XmlResolver = null; // no DTD resolving + redirectedXmlReader.MoveToContent(); + this.fileName = redirectionTarget; + this.encoding = redirectedXmlReader.Encoding; + ReadXmlDoc(redirectedXmlReader); + } + } + } + else + { + throw new XmlException("XmlDoc " + fileName + " is redirecting to " + xmlReader.GetAttribute("redirect") + ", but that file was not found."); + } + } + } + } + } + + static string GetRedirectionTarget(string xmlFileName, string target) + { + var programFilesDir = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86); + programFilesDir = AppendDirectorySeparator(programFilesDir); + + var corSysDir = System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory(); + corSysDir = AppendDirectorySeparator(corSysDir); + + var fileName = target.Replace("%PROGRAMFILESDIR%", programFilesDir) + .Replace("%CORSYSDIR%", corSysDir); + if (!Path.IsPathRooted(fileName)) + fileName = Path.Combine(Path.GetDirectoryName(xmlFileName), fileName); + return LookupLocalizedXmlDoc(fileName); + } + + static string AppendDirectorySeparator(string dir) + { + if (dir.EndsWith("\\", StringComparison.Ordinal) || dir.EndsWith("/", StringComparison.Ordinal)) + return dir; + else + return dir + Path.DirectorySeparatorChar; + } + + /// + /// Given the assembly file name, looks up the XML documentation file name. + /// Returns null if no XML documentation file is found. + /// + public static string LookupLocalizedXmlDoc(string fileName) + { + var xmlFileName = Path.ChangeExtension(fileName, ".xml"); + var currentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName; + var localizedXmlDocFile = GetLocalizedName(xmlFileName, currentCulture); + + Debug.WriteLine("Try find XMLDoc @" + localizedXmlDocFile); + if (File.Exists(localizedXmlDocFile)) + { + return localizedXmlDocFile; + } + Debug.WriteLine("Try find XMLDoc @" + xmlFileName); + if (File.Exists(xmlFileName)) + { + return xmlFileName; + } + if (currentCulture != "en") + { + var englishXmlDocFile = GetLocalizedName(xmlFileName, "en"); + Debug.WriteLine("Try find XMLDoc @" + englishXmlDocFile); + if (File.Exists(englishXmlDocFile)) + { + return englishXmlDocFile; + } + } + return null; + } + + static string GetLocalizedName(string fileName, string language) + { + var localizedXmlDocFile = Path.GetDirectoryName(fileName); + localizedXmlDocFile = Path.Combine(localizedXmlDocFile, language); + localizedXmlDocFile = Path.Combine(localizedXmlDocFile, Path.GetFileName(fileName)); + return localizedXmlDocFile; + } + #endregion + + #region Load / Create Index + void ReadXmlDoc(XmlTextReader reader) + { + //lastWriteDate = File.GetLastWriteTimeUtc(fileName); + // Open up a second file stream for the line<->position mapping + using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete)) + { + var linePosMapper = new LinePositionMapper(fs, encoding); + var indexList = new List(); + while (reader.Read()) + { + if (reader.IsStartElement()) + { + switch (reader.LocalName) + { + case "members": + ReadMembersSection(reader, linePosMapper, indexList); + break; + } + } + } + indexList.Sort(); + this.index = indexList.ToArray(); // volatile write + } + } + + sealed class LinePositionMapper + { + readonly FileStream fs; + readonly Decoder decoder; + int currentLine = 1; + char prevChar = '\0'; + + // buffers for use with Decoder: + byte[] input = new byte[1]; + char[] output = new char[1]; + + public LinePositionMapper(FileStream fs, Encoding encoding) + { + this.decoder = encoding.GetDecoder(); + this.fs = fs; + } + + public int GetPositionForLine(int line) + { + Debug.Assert(line >= currentLine); + while (line > currentLine) + { + var b = fs.ReadByte(); + if (b < 0) + throw new EndOfStreamException(); + input[0] = (byte)b; + decoder.Convert(input, 0, 1, output, 0, 1, false, out var bytesUsed, out var charsUsed, out _); + Debug.Assert(bytesUsed == 1); + if (charsUsed == 1) + { + if ((prevChar != '\r' && output[0] == '\n') || output[0] == '\r') + currentLine++; + prevChar = output[0]; + } + } + return checked((int)fs.Position); + } + } + + static void ReadMembersSection(XmlTextReader reader, LinePositionMapper linePosMapper, List indexList) + { + while (reader.Read()) + { + switch (reader.NodeType) + { + case XmlNodeType.EndElement: + if (reader.LocalName == "members") + { + return; + } + break; + case XmlNodeType.Element: + if (reader.LocalName == "member") + { + var pos = linePosMapper.GetPositionForLine(reader.LineNumber) + Math.Max(reader.LinePosition - 2, 0); + var memberAttr = reader.GetAttribute("name"); + if (memberAttr != null) + indexList.Add(new IndexEntry(GetHashCode(memberAttr), pos)); + reader.Skip(); + } + break; + } + } + } + + /// + /// Hash algorithm used for the index. + /// This is a custom implementation so that old index files work correctly + /// even when the .NET string.GetHashCode implementation changes + /// (e.g. due to .NET 4.5 hash randomization) + /// + static int GetHashCode(string key) + { + unchecked + { + var h = 0; + foreach (var c in key) + { + h = (h << 5) - h + c; + } + return h; + } + } + #endregion + + #region GetDocumentation + /// + /// Get the documentation for the member with the specified documentation key. + /// + public string GetDocumentation(string key) + { + if (key == null) + throw new ArgumentNullException(nameof(key)); + return GetDocumentation(key, true); + } + + /// + /// Get the documentation for the specified member. + /// + public string GetDocumentation(IEntity entity) + { + if (entity == null) + throw new ArgumentNullException(nameof(entity)); + return GetDocumentation(entity.GetIdString()); + } + + string GetDocumentation(string key, bool allowReload) + { + var hashcode = GetHashCode(key); + var index = this.index; // read volatile field + // index is sorted, so we can use binary search + var m = Array.BinarySearch(index, new IndexEntry(hashcode, 0)); + if (m < 0) + return null; + // correct hash code found. + // possibly there are multiple items with the same hash, so go to the first. + while (--m >= 0 && index[m].HashCode == hashcode) + ; + // m is now 1 before the first item with the correct hash + + var cache = this.cache; + lock (cache) + { + if (!cache.TryGet(key, out var val)) + { + try + { + // go through all items that have the correct hash + while (++m < index.Length && index[m].HashCode == hashcode) + { + val = LoadDocumentation(key, index[m].PositionInFile); + if (val != null) + break; + } + // cache the result (even if it is null) + cache.Add(key, val); + } + catch (IOException) + { + // may happen if the documentation file was deleted/is inaccessible/changed (EndOfStreamException) + return allowReload ? ReloadAndGetDocumentation(key) : null; + } + catch (XmlException) + { + // may happen if the documentation file was changed so that the file position no longer starts on a valid XML element + return allowReload ? ReloadAndGetDocumentation(key) : null; + } + } + return val; + } + } + + string ReloadAndGetDocumentation(string key) + { + try + { + // Reload the index + using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete)) + { + using (var xmlReader = new XmlTextReader(fs)) + { + xmlReader.XmlResolver = null; // no DTD resolving + xmlReader.MoveToContent(); + ReadXmlDoc(xmlReader); + } + } + } + catch (IOException) + { + // Ignore errors on reload; IEntity.Documentation callers aren't prepared to handle exceptions + this.index = Empty.Array; // clear index to avoid future load attempts + return null; + } + catch (XmlException) + { + this.index = Empty.Array; // clear index to avoid future load attempts + return null; + } + return GetDocumentation(key, allowReload: false); // prevent infinite reload loops + } + #endregion + + #region Load / Read XML + string LoadDocumentation(string key, int positionInFile) + { + using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete)) + { + fs.Position = positionInFile; + var context = new XmlParserContext(null, null, null, XmlSpace.None) { Encoding = encoding }; + using (var r = new XmlTextReader(fs, XmlNodeType.Element, context)) + { + r.XmlResolver = null; // no DTD resolving + while (r.Read()) + { + if (r.NodeType == XmlNodeType.Element) + { + var memberAttr = r.GetAttribute("name"); + if (memberAttr == key) + { + return r.ReadInnerXml(); + } + else + { + return null; + } + } + } + return null; + } + } + } + #endregion + + public virtual void OnDeserialization(object sender) + { + cache = new XmlDocumentationCache(); + } + } +} diff --git a/src/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj b/src/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj new file mode 100644 index 0000000..20f3b05 --- /dev/null +++ b/src/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj @@ -0,0 +1,51 @@ + + + + + netstandard2.0;net5.0 + + IL decompiler engine + ic#code + ILSpy + Copyright 2011-2020 AlphaSierraPapa for the SharpDevelop Team + en-US + + latest + true + 1701;1702;1591;1573 + false + false + false + true + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + TextTemplatingFileGenerator + ILOpCodes.cs + + + + + + + + + + True + True + ILOpCodes.tt + + + + + diff --git a/src/ICSharpCode.Decompiler/IL/PrimitiveType.cs b/src/ICSharpCode.Decompiler/IL/PrimitiveType.cs new file mode 100644 index 0000000..9d45d54 --- /dev/null +++ b/src/ICSharpCode.Decompiler/IL/PrimitiveType.cs @@ -0,0 +1,52 @@ +// Copyright (c) 2014 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler.IL +{ + public enum PrimitiveType : byte + { + None, + I1 = PrimitiveTypeCode.SByte, + I2 = PrimitiveTypeCode.Int16, + I4 = PrimitiveTypeCode.Int32, + I8 = PrimitiveTypeCode.Int64, + R4 = PrimitiveTypeCode.Single, + R8 = PrimitiveTypeCode.Double, + U1 = PrimitiveTypeCode.Byte, + U2 = PrimitiveTypeCode.UInt16, + U4 = PrimitiveTypeCode.UInt32, + U8 = PrimitiveTypeCode.UInt64, + I = PrimitiveTypeCode.IntPtr, + U = PrimitiveTypeCode.UIntPtr, + /// Managed reference + Ref = 16, + /// Floating point type of unspecified size: + /// usually 80 bits on x86 (when the runtime uses x87 instructions); + /// but only 64-bit on x64. + /// This only occurs for "conv.r.un" instructions. The C# compiler usually follows those + /// with a "conv.r4" or "conv.r8" instruction to indicate the desired float type, so + /// we only use this as conversion target type and don't bother tracking it as its own stack type: + /// basically everything treats R identical to R8, except for the (conv.r.un + conv.r[48] => conv.r[48].un) + /// combining logic which should not combine (conv.r.un + conv.r8 + conv.r4) into a single conv.r4.un. + /// + R = 254, + Unknown = 255 + } +} diff --git a/src/ICSharpCode.Decompiler/IL/StackType.cs b/src/ICSharpCode.Decompiler/IL/StackType.cs new file mode 100644 index 0000000..6c30316 --- /dev/null +++ b/src/ICSharpCode.Decompiler/IL/StackType.cs @@ -0,0 +1,74 @@ +// Copyright (c) 2014 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + + +namespace ICSharpCode.Decompiler.IL +{ + /// + /// A type for the purpose of stack analysis. + /// + public enum StackType : byte + { + // Note: the numeric of these enum members is relevant for ILReader.MergeStacks: + // when two branches meet where a stack slot has different types, the type after + // the branch is the one with the higher numeric value. + + /// + /// The stack type is unknown; for example a call returning an unknown type + /// because an assembly reference isn't loaded. + /// Can also occur with invalid IL. + /// + Unknown, + /// 32-bit integer + /// + /// Used for C# int, uint, + /// C# small integer types byte, sbyte, short, ushort, + /// bool and char, + /// and any enums with one of the above as underlying type. + /// + I4, + /// native-size integer, or unmanaged pointer + /// + /// Used for C# IntPtr, UIntPtr and any native pointer types (void* etc.) + /// Also used for IL function pointer types. + /// + I, + /// 64-bit integer + /// + /// Used for C# long, ulong, + /// and any enums with one of the above as underlying type. + /// + I8, + /// 32-bit floating point number + /// + /// Used for C# float. + /// + F4, + /// 64-bit floating point number + /// + /// Used for C# double. + /// + F8, + /// Another stack type. Includes objects, value types, ... + O, + /// A managed pointer + Ref, + /// Represents the lack of a stack slot + Void + } +} diff --git a/src/ICSharpCode.Decompiler/ITextOutput.cs b/src/ICSharpCode.Decompiler/ITextOutput.cs new file mode 100644 index 0000000..0a7bdc9 --- /dev/null +++ b/src/ICSharpCode.Decompiler/ITextOutput.cs @@ -0,0 +1,64 @@ +// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + + +using System.Reflection.Metadata; + +using ICSharpCode.Decompiler.Disassembler; +using ICSharpCode.Decompiler.Metadata; +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler +{ + public interface ITextOutput + { + string IndentationString { get; set; } + void Indent(); + void Unindent(); + void Write(char ch); + void Write(string text); + void WriteLine(); + void WriteReference(OpCodeInfo opCode, bool omitSuffix = false); + void WriteReference(PEFile module, Handle handle, string text, string protocol = "decompile", bool isDefinition = false); + void WriteReference(IType type, string text, bool isDefinition = false); + void WriteReference(IMember member, string text, bool isDefinition = false); + void WriteLocalReference(string text, object reference, bool isDefinition = false); + + void MarkFoldStart(string collapsedText = "...", bool defaultCollapsed = false); + void MarkFoldEnd(); + } + + public static class TextOutputExtensions + { + public static void Write(this ITextOutput output, string format, params object[] args) + { + output.Write(string.Format(format, args)); + } + + public static void WriteLine(this ITextOutput output, string text) + { + output.Write(text); + output.WriteLine(); + } + + public static void WriteLine(this ITextOutput output, string format, params object[] args) + { + output.WriteLine(string.Format(format, args)); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/AssemblyReferences.cs b/src/ICSharpCode.Decompiler/Metadata/AssemblyReferences.cs new file mode 100644 index 0000000..740ade3 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/AssemblyReferences.cs @@ -0,0 +1,278 @@ +// Copyright (c) 2018 Siegfried Pammer +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Security.Cryptography; +using System.Text; + +namespace ICSharpCode.Decompiler.Metadata +{ + public sealed class AssemblyResolutionException : FileNotFoundException + { + public IAssemblyReference Reference { get; } + + public AssemblyResolutionException(IAssemblyReference reference) + : this(reference, null) + { + } + + public AssemblyResolutionException(IAssemblyReference reference, Exception innerException) + : base($"Failed to resolve assembly: '{reference}'", innerException) + { + this.Reference = reference; + } + } + + public interface IAssemblyResolver + { +#if !VSADDIN + PEFile Resolve(IAssemblyReference reference); + PEFile ResolveModule(PEFile mainModule, string moduleName); +#endif + } + + public class AssemblyReferenceClassifier + { + /// + /// For GAC assembly references, the WholeProjectDecompiler will omit the HintPath in the + /// generated .csproj file. + /// + public virtual bool IsGacAssembly(IAssemblyReference reference) + { + return UniversalAssemblyResolver.GetAssemblyInGac(reference) != null; + } + + /// + /// For .NET Core framework references, the WholeProjectDecompiler will omit the + /// assembly reference if the runtimePack is already included as an SDK. + /// + public virtual bool IsSharedAssembly(IAssemblyReference reference, out string runtimePack) + { + runtimePack = null; + return false; + } + } + + public interface IAssemblyReference + { + string Name { get; } + string FullName { get; } + Version Version { get; } + string Culture { get; } + byte[] PublicKeyToken { get; } + + bool IsWindowsRuntime { get; } + bool IsRetargetable { get; } + } + + public class AssemblyNameReference : IAssemblyReference + { + string fullName; + + public string Name { get; private set; } + + public string FullName { + get { + if (fullName != null) + return fullName; + + const string sep = ", "; + + var builder = new StringBuilder(); + builder.Append(Name); + builder.Append(sep); + builder.Append("Version="); + builder.Append((Version ?? UniversalAssemblyResolver.ZeroVersion).ToString(fieldCount: 4)); + builder.Append(sep); + builder.Append("Culture="); + builder.Append(string.IsNullOrEmpty(Culture) ? "neutral" : Culture); + builder.Append(sep); + builder.Append("PublicKeyToken="); + + var pk_token = PublicKeyToken; + if (pk_token != null && pk_token.Length > 0) + { + for (var i = 0; i < pk_token.Length; i++) + { + builder.Append(pk_token[i].ToString("x2")); + } + } + else + builder.Append("null"); + + if (IsRetargetable) + { + builder.Append(sep); + builder.Append("Retargetable=Yes"); + } + + return fullName = builder.ToString(); + } + } + + public Version Version { get; private set; } + + public string Culture { get; private set; } + + public byte[] PublicKeyToken { get; private set; } + + public bool IsWindowsRuntime { get; private set; } + + public bool IsRetargetable { get; private set; } + + public static AssemblyNameReference Parse(string fullName) + { + if (fullName == null) + throw new ArgumentNullException(nameof(fullName)); + if (fullName.Length == 0) + throw new ArgumentException("Name can not be empty"); + + var name = new AssemblyNameReference(); + var tokens = fullName.Split(','); + for (var i = 0; i < tokens.Length; i++) + { + var token = tokens[i].Trim(); + + if (i == 0) + { + name.Name = token; + continue; + } + + var parts = token.Split('='); + if (parts.Length != 2) + throw new ArgumentException("Malformed name"); + + switch (parts[0].ToLowerInvariant()) + { + case "version": + name.Version = new Version(parts[1]); + break; + case "culture": + name.Culture = parts[1] == "neutral" ? "" : parts[1]; + break; + case "publickeytoken": + var pk_token = parts[1]; + if (pk_token == "null") + break; + + name.PublicKeyToken = new byte[pk_token.Length / 2]; + for (var j = 0; j < name.PublicKeyToken.Length; j++) + name.PublicKeyToken[j] = Byte.Parse(pk_token.Substring(j * 2, 2), System.Globalization.NumberStyles.HexNumber); + + break; + } + } + + return name; + } + + public override string ToString() + { + return FullName; + } + } + +#if !VSADDIN + public class AssemblyReference : IAssemblyReference + { + static readonly SHA1 sha1 = SHA1.Create(); + + readonly System.Reflection.Metadata.AssemblyReference entry; + + public MetadataReader Metadata { get; } + public AssemblyReferenceHandle Handle { get; } + + public bool IsWindowsRuntime => (entry.Flags & AssemblyFlags.WindowsRuntime) != 0; + public bool IsRetargetable => (entry.Flags & AssemblyFlags.Retargetable) != 0; + + public string Name { + get { + try + { + return Metadata.GetString(entry.Name); + } + catch (BadImageFormatException) + { + return $"AR:{Handle}"; + } + } + } + + public string FullName { + get { + try + { + return entry.GetFullAssemblyName(Metadata); + } + catch (BadImageFormatException) + { + return $"fullname(AR:{Handle})"; + } + } + } + + public Version Version => entry.Version; + public string Culture => Metadata.GetString(entry.Culture); + byte[] IAssemblyReference.PublicKeyToken => GetPublicKeyToken(); + + public byte[] GetPublicKeyToken() + { + if (entry.PublicKeyOrToken.IsNil) + return null; + var bytes = Metadata.GetBlobBytes(entry.PublicKeyOrToken); + if ((entry.Flags & AssemblyFlags.PublicKey) != 0) + { + return sha1.ComputeHash(bytes).Skip(12).ToArray(); + } + return bytes; + } + + public AssemblyReference(MetadataReader metadata, AssemblyReferenceHandle handle) + { + if (metadata == null) + throw new ArgumentNullException(nameof(metadata)); + if (handle.IsNil) + throw new ArgumentNullException(nameof(handle)); + Metadata = metadata; + Handle = handle; + entry = metadata.GetAssemblyReference(handle); + } + + public AssemblyReference(PEFile module, AssemblyReferenceHandle handle) + { + if (module == null) + throw new ArgumentNullException(nameof(module)); + if (handle.IsNil) + throw new ArgumentNullException(nameof(handle)); + Metadata = module.Metadata; + Handle = handle; + entry = Metadata.GetAssemblyReference(handle); + } + + public override string ToString() + { + return FullName; + } + } +#endif +} diff --git a/src/ICSharpCode.Decompiler/Metadata/CodeMappingInfo.cs b/src/ICSharpCode.Decompiler/Metadata/CodeMappingInfo.cs new file mode 100644 index 0000000..241996e --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/CodeMappingInfo.cs @@ -0,0 +1,98 @@ +// Copyright (c) 2018 Siegfried Pammer +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler.Metadata +{ + /// + /// Describes which parts of the (compiler-generated) code belong to which user code. + /// A part could be: + /// - the body (method) of a lambda. + /// - the MoveNext method of async/yield state machines. + /// + public class CodeMappingInfo + { + /// + /// The module containing the code. + /// + public PEFile Module { get; } + + /// + /// The (parent) TypeDef containing the code. + /// + public TypeDefinitionHandle TypeDefinition { get; } + + readonly Dictionary> parts; + readonly Dictionary parents; + + /// + /// Creates a instance using the given and . + /// + public CodeMappingInfo(PEFile module, TypeDefinitionHandle type) + { + this.Module = module; + this.TypeDefinition = type; + this.parts = new Dictionary>(); + this.parents = new Dictionary(); + } + + /// + /// Returns all parts of a method. + /// A method has at least one part, that is, the method itself. + /// If no parts are found, only the method itself is returned. + /// + public IEnumerable GetMethodParts(MethodDefinitionHandle method) + { + if (parts.TryGetValue(method, out var p)) + return p; + return new[] { method }; + } + + /// + /// Returns the parent of a part. + /// The parent is usually the "calling method" of lambdas, async and yield state machines. + /// The "calling method" has itself as parent. + /// If no parent is found, the method itself is returned. + /// + public MethodDefinitionHandle GetParentMethod(MethodDefinitionHandle method) + { + if (parents.TryGetValue(method, out var p)) + return p; + return method; + } + + /// + /// Adds a bidirectional mapping between and . + /// + public void AddMapping(MethodDefinitionHandle parent, MethodDefinitionHandle part) + { + //Debug.Print("Parent: " + MetadataTokens.GetRowNumber(parent) + " Part: " + MetadataTokens.GetRowNumber(part)); + if (parents.ContainsKey(part)) + return; + parents.Add(part, parent); + if (!parts.TryGetValue(parent, out var list)) + { + list = new List(); + parts.Add(parent, list); + } + list.Add(part); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/CustomAttributeDecoder.cs b/src/ICSharpCode.Decompiler/Metadata/CustomAttributeDecoder.cs new file mode 100644 index 0000000..6449532 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/CustomAttributeDecoder.cs @@ -0,0 +1,235 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Collections.Immutable; +using System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler.Metadata +{ + /// + /// Decodes custom attribute blobs. + /// + internal readonly struct CustomAttributeDecoder + { + // This is a stripped-down copy of SRM's internal CustomAttributeDecoder. + // We need it to decode security declarations. + + private readonly ICustomAttributeTypeProvider _provider; + private readonly MetadataReader _reader; + private readonly bool _provideBoxingTypeInfo; + + public CustomAttributeDecoder(ICustomAttributeTypeProvider provider, MetadataReader reader, bool provideBoxingTypeInfo = false) + { + _reader = reader; + _provider = provider; + _provideBoxingTypeInfo = provideBoxingTypeInfo; + } + + public ImmutableArray> DecodeNamedArguments(ref BlobReader valueReader, int count) + { + var arguments = ImmutableArray.CreateBuilder>(count); + for (var i = 0; i < count; i++) + { + var kind = (CustomAttributeNamedArgumentKind)valueReader.ReadSerializationTypeCode(); + if (kind != CustomAttributeNamedArgumentKind.Field && kind != CustomAttributeNamedArgumentKind.Property) + { + throw new BadImageFormatException(); + } + + var info = DecodeNamedArgumentType(ref valueReader); + var name = valueReader.ReadSerializedString(); + var argument = DecodeArgument(ref valueReader, info); + arguments.Add(new CustomAttributeNamedArgument(name, kind, argument.Type, argument.Value)); + } + + return arguments.MoveToImmutable(); + } + + private struct ArgumentTypeInfo + { + public TType Type; + public TType ElementType; + public SerializationTypeCode TypeCode; + public SerializationTypeCode ElementTypeCode; + } + + private ArgumentTypeInfo DecodeNamedArgumentType(ref BlobReader valueReader, bool isElementType = false) + { + var info = new ArgumentTypeInfo { + TypeCode = valueReader.ReadSerializationTypeCode(), + }; + + switch (info.TypeCode) + { + case SerializationTypeCode.Boolean: + case SerializationTypeCode.Byte: + case SerializationTypeCode.Char: + case SerializationTypeCode.Double: + case SerializationTypeCode.Int16: + case SerializationTypeCode.Int32: + case SerializationTypeCode.Int64: + case SerializationTypeCode.SByte: + case SerializationTypeCode.Single: + case SerializationTypeCode.String: + case SerializationTypeCode.UInt16: + case SerializationTypeCode.UInt32: + case SerializationTypeCode.UInt64: + info.Type = _provider.GetPrimitiveType((PrimitiveTypeCode)info.TypeCode); + break; + + case SerializationTypeCode.Type: + info.Type = _provider.GetSystemType(); + break; + + case SerializationTypeCode.TaggedObject: + info.Type = _provider.GetPrimitiveType(PrimitiveTypeCode.Object); + break; + + case SerializationTypeCode.SZArray: + if (isElementType) + { + // jagged arrays are not allowed. + throw new BadImageFormatException(); + } + + var elementInfo = DecodeNamedArgumentType(ref valueReader, isElementType: true); + info.ElementType = elementInfo.Type; + info.ElementTypeCode = elementInfo.TypeCode; + info.Type = _provider.GetSZArrayType(info.ElementType); + break; + + case SerializationTypeCode.Enum: + var typeName = valueReader.ReadSerializedString(); + info.Type = _provider.GetTypeFromSerializedName(typeName); + info.TypeCode = (SerializationTypeCode)_provider.GetUnderlyingEnumType(info.Type); + break; + + default: + throw new BadImageFormatException(); + } + + return info; + } + + private CustomAttributeTypedArgument DecodeArgument(ref BlobReader valueReader, ArgumentTypeInfo info) + { + var outer = info; + if (info.TypeCode == SerializationTypeCode.TaggedObject) + { + info = DecodeNamedArgumentType(ref valueReader); + } + + // PERF_TODO: https://github.com/dotnet/corefx/issues/6533 + // Cache /reuse common arguments to avoid boxing (small integers, true, false). + object value; + switch (info.TypeCode) + { + case SerializationTypeCode.Boolean: + value = valueReader.ReadBoolean(); + break; + + case SerializationTypeCode.Byte: + value = valueReader.ReadByte(); + break; + + case SerializationTypeCode.Char: + value = valueReader.ReadChar(); + break; + + case SerializationTypeCode.Double: + value = valueReader.ReadDouble(); + break; + + case SerializationTypeCode.Int16: + value = valueReader.ReadInt16(); + break; + + case SerializationTypeCode.Int32: + value = valueReader.ReadInt32(); + break; + + case SerializationTypeCode.Int64: + value = valueReader.ReadInt64(); + break; + + case SerializationTypeCode.SByte: + value = valueReader.ReadSByte(); + break; + + case SerializationTypeCode.Single: + value = valueReader.ReadSingle(); + break; + + case SerializationTypeCode.UInt16: + value = valueReader.ReadUInt16(); + break; + + case SerializationTypeCode.UInt32: + value = valueReader.ReadUInt32(); + break; + + case SerializationTypeCode.UInt64: + value = valueReader.ReadUInt64(); + break; + + case SerializationTypeCode.String: + value = valueReader.ReadSerializedString(); + break; + + case SerializationTypeCode.Type: + var typeName = valueReader.ReadSerializedString(); + value = _provider.GetTypeFromSerializedName(typeName); + break; + + case SerializationTypeCode.SZArray: + value = DecodeArrayArgument(ref valueReader, info); + break; + + default: + throw new BadImageFormatException(); + } + + if (_provideBoxingTypeInfo && outer.TypeCode == SerializationTypeCode.TaggedObject) + { + return new CustomAttributeTypedArgument(outer.Type, new CustomAttributeTypedArgument(info.Type, value)); + } + + return new CustomAttributeTypedArgument(info.Type, value); + } + + private ImmutableArray>? DecodeArrayArgument(ref BlobReader blobReader, ArgumentTypeInfo info) + { + var count = blobReader.ReadInt32(); + if (count == -1) + { + return null; + } + + if (count == 0) + { + return ImmutableArray>.Empty; + } + + if (count < 0) + { + throw new BadImageFormatException(); + } + + var elementInfo = new ArgumentTypeInfo { + Type = info.ElementType, + TypeCode = info.ElementTypeCode, + }; + + var array = ImmutableArray.CreateBuilder>(count); + + for (var i = 0; i < count; i++) + { + array.Add(DecodeArgument(ref blobReader, elementInfo)); + } + + return array.MoveToImmutable(); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/Dom.cs b/src/ICSharpCode.Decompiler/Metadata/Dom.cs new file mode 100644 index 0000000..ca7fb19 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/Dom.cs @@ -0,0 +1,300 @@ +using System; +using System.Collections.Immutable; +using System.IO; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; + +using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.Metadata +{ + public enum TargetRuntime + { + Unknown, + Net_1_0, + Net_1_1, + Net_2_0, + Net_4_0 + } + + public enum ResourceType + { + Linked, + Embedded, + AssemblyLinked, + } + + public abstract class Resource + { + public virtual ResourceType ResourceType => ResourceType.Embedded; + public virtual ManifestResourceAttributes Attributes => ManifestResourceAttributes.Public; + public abstract string Name { get; } + public abstract Stream TryOpenStream(); + } + + public class ByteArrayResource : Resource + { + public override string Name { get; } + byte[] data; + + public ByteArrayResource(string name, byte[] data) + { + this.Name = name ?? throw new ArgumentNullException(nameof(name)); + this.data = data ?? throw new ArgumentNullException(nameof(data)); + } + + public override Stream TryOpenStream() + { + return new MemoryStream(data); + } + } + + sealed class MetadataResource : Resource + { + public PEFile Module { get; } + public ManifestResourceHandle Handle { get; } + public bool IsNil => Handle.IsNil; + + public MetadataResource(PEFile module, ManifestResourceHandle handle) + { + this.Module = module ?? throw new ArgumentNullException(nameof(module)); + this.Handle = handle; + } + + ManifestResource This() => Module.Metadata.GetManifestResource(Handle); + + public bool Equals(MetadataResource other) + { + return Module == other.Module && Handle == other.Handle; + } + + public override bool Equals(object obj) + { + if (obj is MetadataResource res) + return Equals(res); + return false; + } + + public override int GetHashCode() + { + return unchecked(982451629 * Module.GetHashCode() + 982451653 * MetadataTokens.GetToken(Handle)); + } + + public override string Name => Module.Metadata.GetString(This().Name); + + public override ManifestResourceAttributes Attributes => This().Attributes; + public bool HasFlag(ManifestResourceAttributes flag) => (Attributes & flag) == flag; + public override ResourceType ResourceType => GetResourceType(); + + ResourceType GetResourceType() + { + if (This().Implementation.IsNil) + return ResourceType.Embedded; + if (This().Implementation.Kind == HandleKind.AssemblyReference) + return ResourceType.AssemblyLinked; + return ResourceType.Linked; + } + + public override unsafe Stream TryOpenStream() + { + if (ResourceType != ResourceType.Embedded) + return null; + var headers = Module.Reader.PEHeaders; + var resources = headers.CorHeader.ResourcesDirectory; + var sectionData = Module.Reader.GetSectionData(resources.RelativeVirtualAddress); + if (sectionData.Length == 0) + throw new BadImageFormatException("RVA could not be found in any section!"); + var reader = sectionData.GetReader(); + reader.Offset += (int)This().Offset; + var length = reader.ReadInt32(); + if (length < 0 || length > reader.RemainingBytes) + throw new BadImageFormatException("Resource stream length invalid"); + return new ResourceMemoryStream(Module.Reader, reader.CurrentPointer, length); + } + } + + sealed unsafe class ResourceMemoryStream : UnmanagedMemoryStream + { + readonly PEReader peReader; + + public ResourceMemoryStream(PEReader peReader, byte* data, long length) + : base(data, length, length, FileAccess.Read) + { + // Keep the PEReader alive while the stream in in use. + this.peReader = peReader; + } + } + + public sealed class FullTypeNameSignatureDecoder : ISignatureTypeProvider, ICustomAttributeTypeProvider + { + readonly MetadataReader metadata; + + public FullTypeNameSignatureDecoder(MetadataReader metadata) + { + this.metadata = metadata; + } + + public FullTypeName GetArrayType(FullTypeName elementType, ArrayShape shape) + { + return elementType; + } + + public FullTypeName GetByReferenceType(FullTypeName elementType) + { + return elementType; + } + + public FullTypeName GetFunctionPointerType(MethodSignature signature) + { + return default; + } + + public FullTypeName GetGenericInstantiation(FullTypeName genericType, ImmutableArray typeArguments) + { + return genericType; + } + + public FullTypeName GetGenericMethodParameter(Unit genericContext, int index) + { + return default; + } + + public FullTypeName GetGenericTypeParameter(Unit genericContext, int index) + { + return default; + } + + public FullTypeName GetModifiedType(FullTypeName modifier, FullTypeName unmodifiedType, bool isRequired) + { + return unmodifiedType; + } + + public FullTypeName GetPinnedType(FullTypeName elementType) + { + return elementType; + } + + public FullTypeName GetPointerType(FullTypeName elementType) + { + return elementType; + } + + public FullTypeName GetPrimitiveType(PrimitiveTypeCode typeCode) + { + var ktr = KnownTypeReference.Get(typeCode.ToKnownTypeCode()); + return new TopLevelTypeName(ktr.Namespace, ktr.Name, ktr.TypeParameterCount); + } + + public FullTypeName GetSystemType() + { + return new TopLevelTypeName("System", "Type"); + } + + public FullTypeName GetSZArrayType(FullTypeName elementType) + { + return elementType; + } + + public FullTypeName GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, byte rawTypeKind) + { + return handle.GetFullTypeName(reader); + } + + public FullTypeName GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, byte rawTypeKind) + { + return handle.GetFullTypeName(reader); + } + + public FullTypeName GetTypeFromSerializedName(string name) + { + return new FullTypeName(name); + } + + public FullTypeName GetTypeFromSpecification(MetadataReader reader, Unit genericContext, TypeSpecificationHandle handle, byte rawTypeKind) + { + return reader.GetTypeSpecification(handle).DecodeSignature(new FullTypeNameSignatureDecoder(metadata), default); + } + + public PrimitiveTypeCode GetUnderlyingEnumType(FullTypeName type) + { + throw new NotImplementedException(); + } + + public bool IsSystemType(FullTypeName type) + { + return type.IsKnownType(KnownTypeCode.Type); + } + } + + public class GenericContext + { + readonly MetadataReader metadata; + readonly TypeDefinitionHandle declaringType; + readonly MethodDefinitionHandle method; + + public static readonly GenericContext Empty = new GenericContext(); + + private GenericContext() { } + + public GenericContext(MethodDefinitionHandle method, PEFile module) + { + this.metadata = module.Metadata; + this.method = method; + this.declaringType = module.Metadata.GetMethodDefinition(method).GetDeclaringType(); + } + + public GenericContext(MethodDefinitionHandle method, MetadataReader metadata) + { + this.metadata = metadata; + this.method = method; + this.declaringType = metadata.GetMethodDefinition(method).GetDeclaringType(); + } + + public GenericContext(TypeDefinitionHandle declaringType, PEFile module) + { + this.metadata = module.Metadata; + this.declaringType = declaringType; + } + + public GenericContext(TypeDefinitionHandle declaringType, MetadataReader metadata) + { + this.metadata = metadata; + this.declaringType = declaringType; + } + + public string GetGenericTypeParameterName(int index) + { + var genericParameter = GetGenericTypeParameterHandleOrNull(index); + if (genericParameter.IsNil) + return index.ToString(); + return metadata.GetString(metadata.GetGenericParameter(genericParameter).Name); + } + + public string GetGenericMethodTypeParameterName(int index) + { + var genericParameter = GetGenericMethodTypeParameterHandleOrNull(index); + if (genericParameter.IsNil) + return index.ToString(); + return metadata.GetString(metadata.GetGenericParameter(genericParameter).Name); + } + + public GenericParameterHandle GetGenericTypeParameterHandleOrNull(int index) + { + GenericParameterHandleCollection genericParameters; + if (declaringType.IsNil || index < 0 || index >= (genericParameters = metadata.GetTypeDefinition(declaringType).GetGenericParameters()).Count) + return MetadataTokens.GenericParameterHandle(0); + return genericParameters[index]; + } + + public GenericParameterHandle GetGenericMethodTypeParameterHandleOrNull(int index) + { + GenericParameterHandleCollection genericParameters; + if (method.IsNil || index < 0 || index >= (genericParameters = metadata.GetMethodDefinition(method).GetGenericParameters()).Count) + return MetadataTokens.GenericParameterHandle(0); + return genericParameters[index]; + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/DotNetCorePathFinder.cs b/src/ICSharpCode.Decompiler/Metadata/DotNetCorePathFinder.cs new file mode 100644 index 0000000..e079077 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/DotNetCorePathFinder.cs @@ -0,0 +1,294 @@ +// Copyright (c) 2018 Siegfried Pammer +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; + +using ICSharpCode.Decompiler.Util; + +using LightJson.Serialization; + +namespace ICSharpCode.Decompiler.Metadata +{ + public class DotNetCorePathFinder + { + class DotNetCorePackageInfo + { + public readonly string Name; + public readonly string Version; + public readonly string Type; + public readonly string Path; + public readonly string[] RuntimeComponents; + + public DotNetCorePackageInfo(string fullName, string type, string path, string[] runtimeComponents) + { + var parts = fullName.Split('/'); + this.Name = parts[0]; + if (parts.Length > 1) + { + this.Version = parts[1]; + } + else + { + this.Version = ""; + } + + this.Type = type; + this.Path = path; + this.RuntimeComponents = runtimeComponents ?? Empty.Array; + } + } + + static readonly string[] LookupPaths = new string[] { + Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".nuget", "packages") + }; + + static readonly string[] RuntimePacks = new[] { + "Microsoft.NETCore.App", + "Microsoft.WindowsDesktop.App", + "Microsoft.AspNetCore.App", + "Microsoft.AspNetCore.All" + }; + + readonly DotNetCorePackageInfo[] packages; + readonly List searchPaths = new List(); + readonly List packageBasePaths = new List(); + readonly Version targetFrameworkVersion; + readonly string dotnetBasePath = FindDotNetExeDirectory(); + + public DotNetCorePathFinder(TargetFrameworkIdentifier targetFramework, Version targetFrameworkVersion) + { + this.targetFrameworkVersion = targetFrameworkVersion; + + if (targetFramework == TargetFrameworkIdentifier.NETStandard) + { + // .NET Standard 2.1 is implemented by .NET Core 3.0 or higher + if (targetFrameworkVersion.Major == 2 && targetFrameworkVersion.Minor == 1) + { + this.targetFrameworkVersion = new Version(3, 0, 0); + } + } + } + + public DotNetCorePathFinder(string parentAssemblyFileName, string targetFrameworkIdString, TargetFrameworkIdentifier targetFramework, Version targetFrameworkVersion, ReferenceLoadInfo loadInfo = null) + : this(targetFramework, targetFrameworkVersion) + { + var assemblyName = Path.GetFileNameWithoutExtension(parentAssemblyFileName); + var basePath = Path.GetDirectoryName(parentAssemblyFileName); + + searchPaths.Add(basePath); + + var depsJsonFileName = Path.Combine(basePath, $"{assemblyName}.deps.json"); + if (File.Exists(depsJsonFileName)) + { + packages = LoadPackageInfos(depsJsonFileName, targetFrameworkIdString).ToArray(); + + foreach (var path in LookupPaths) + { + foreach (var p in packages) + { + foreach (var item in p.RuntimeComponents) + { + var itemPath = Path.GetDirectoryName(item); + var fullPath = Path.Combine(path, p.Name, p.Version, itemPath).ToLowerInvariant(); + if (Directory.Exists(fullPath)) + packageBasePaths.Add(fullPath); + } + } + } + } + else + { + loadInfo?.AddMessage(assemblyName, MessageKind.Warning, $"{assemblyName}.deps.json could not be found!"); + } + } + + public void AddSearchDirectory(string path) + { + this.searchPaths.Add(path); + } + + public void RemoveSearchDirectory(string path) + { + this.searchPaths.Remove(path); + } + + public string TryResolveDotNetCore(IAssemblyReference name) + { + foreach (var basePath in searchPaths.Concat(packageBasePaths)) + { + if (File.Exists(Path.Combine(basePath, name.Name + ".dll"))) + { + return Path.Combine(basePath, name.Name + ".dll"); + } + else if (File.Exists(Path.Combine(basePath, name.Name + ".exe"))) + { + return Path.Combine(basePath, name.Name + ".exe"); + } + } + + return TryResolveDotNetCoreShared(name, out _); + } + + internal string GetReferenceAssemblyPath(string targetFramework) + { + var (tfi, version) = UniversalAssemblyResolver.ParseTargetFramework(targetFramework); + string identifier, identifierExt; + switch (tfi) + { + case TargetFrameworkIdentifier.NETCoreApp: + identifier = "Microsoft.NETCore.App"; + identifierExt = "netcoreapp" + version.Major + "." + version.Minor; + break; + case TargetFrameworkIdentifier.NETStandard: + identifier = "NETStandard.Library"; + identifierExt = "netstandard" + version.Major + "." + version.Minor; + break; + default: + throw new NotSupportedException(); + } + return Path.Combine(dotnetBasePath, "packs", identifier + ".Ref", version.ToString(), "ref", identifierExt); + } + + static IEnumerable LoadPackageInfos(string depsJsonFileName, string targetFramework) + { + var dependencies = JsonReader.Parse(File.ReadAllText(depsJsonFileName)); + var runtimeInfos = dependencies["targets"][targetFramework].AsJsonObject; + var libraries = dependencies["libraries"].AsJsonObject; + if (runtimeInfos == null || libraries == null) + yield break; + foreach (var library in libraries) + { + var type = library.Value["type"].AsString; + var path = library.Value["path"].AsString; + var runtimeInfo = runtimeInfos[library.Key].AsJsonObject?["runtime"].AsJsonObject; + var components = new string[runtimeInfo?.Count ?? 0]; + if (runtimeInfo != null) + { + var i = 0; + foreach (var component in runtimeInfo) + { + components[i] = component.Key; + i++; + } + } + yield return new DotNetCorePackageInfo(library.Key, type, path, components); + } + } + + public string TryResolveDotNetCoreShared(IAssemblyReference name, out string runtimePack) + { + if (dotnetBasePath == null) + { + runtimePack = null; + return null; + } + foreach (var pack in RuntimePacks) + { + runtimePack = pack; + var basePath = Path.Combine(dotnetBasePath, "shared", pack); + if (!Directory.Exists(basePath)) + continue; + var closestVersion = GetClosestVersionFolder(basePath, targetFrameworkVersion); + if (File.Exists(Path.Combine(basePath, closestVersion, name.Name + ".dll"))) + { + return Path.Combine(basePath, closestVersion, name.Name + ".dll"); + } + else if (File.Exists(Path.Combine(basePath, closestVersion, name.Name + ".exe"))) + { + return Path.Combine(basePath, closestVersion, name.Name + ".exe"); + } + } + runtimePack = null; + return null; + } + + static string GetClosestVersionFolder(string basePath, Version version) + { + var foundVersions = new DirectoryInfo(basePath).GetDirectories() + .Select(d => ConvertToVersion(d.Name)) + .Where(v => v.version != null); + foreach (var folder in foundVersions.OrderBy(v => v.Item1)) + { + if (folder.version >= version) + return folder.directoryName; + } + return version.ToString(); + } + + internal static (Version version, string directoryName) ConvertToVersion(string name) + { + string RemoveTrailingVersionInfo() + { + var shortName = name; + var dashIndex = shortName.IndexOf('-'); + if (dashIndex > 0) + { + shortName = shortName.Remove(dashIndex); + } + return shortName; + } + + try + { + return (new Version(RemoveTrailingVersionInfo()), name); + } + catch (Exception ex) + { + Trace.TraceWarning(ex.ToString()); + return (null, null); + } + } + + public static string FindDotNetExeDirectory() + { + var dotnetExeName = (Environment.OSVersion.Platform == PlatformID.Unix) ? "dotnet" : "dotnet.exe"; + foreach (var item in Environment.GetEnvironmentVariable("PATH").Split(Path.PathSeparator)) + { + try + { + var fileName = Path.Combine(item, dotnetExeName); + if (!File.Exists(fileName)) + continue; + if (Environment.OSVersion.Platform == PlatformID.Unix) + { + if ((new FileInfo(fileName).Attributes & FileAttributes.ReparsePoint) == FileAttributes.ReparsePoint) + { + var sb = new StringBuilder(); + realpath(fileName, sb); + fileName = sb.ToString(); + if (!File.Exists(fileName)) + continue; + } + } + return Path.GetDirectoryName(fileName); + } + catch (ArgumentException) { } + } + return null; + } + + [DllImport("libc")] + static extern void realpath(string path, StringBuilder resolvedPath); + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/DotNetCorePathFinderExtensions.cs b/src/ICSharpCode.Decompiler/Metadata/DotNetCorePathFinderExtensions.cs new file mode 100644 index 0000000..aea9fea --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/DotNetCorePathFinderExtensions.cs @@ -0,0 +1,246 @@ +// Copyright (c) 2018 Siegfried Pammer +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection.Metadata; +using System.Reflection.PortableExecutable; +using System.Text.RegularExpressions; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Metadata +{ + public static class DotNetCorePathFinderExtensions + { + static readonly string PathPattern = + @"(Reference Assemblies[/\\]Microsoft[/\\]Framework[/\\](?.NETFramework)[/\\]v(?[^/\\]+)[/\\])" + + @"|((?Microsoft\.NET)[/\\]assembly[/\\]GAC_(MSIL|32|64)[/\\])" + + @"|((?Microsoft\.NET)[/\\]Framework(64)?[/\\](?[^/\\]+)[/\\])" + + @"|(NuGetFallbackFolder[/\\](?[^/\\]+)\\(?[^/\\]+)([/\\].*)?[/\\]ref[/\\])" + + @"|(shared[/\\](?[^/\\]+)\\(?[^/\\]+)([/\\].*)?[/\\])" + + @"|(packs[/\\](?[^/\\]+)\\(?[^/\\]+)\\ref([/\\].*)?[/\\])"; + + static readonly string RefPathPattern = + @"(Reference Assemblies[/\\]Microsoft[/\\]Framework[/\\](?.NETFramework)[/\\]v(?[^/\\]+)[/\\])" + + @"|(NuGetFallbackFolder[/\\](?[^/\\]+)\\(?[^/\\]+)([/\\].*)?[/\\]ref[/\\])" + + @"|(packs[/\\](?[^/\\]+)\\(?[^/\\]+)\\ref([/\\].*)?[/\\])"; + + public static string DetectTargetFrameworkId(this PEFile assembly) + { + return DetectTargetFrameworkId(assembly.Reader, assembly.FileName); + } + + public static string DetectTargetFrameworkId(this PEReader assembly, string assemblyPath = null) + { + if (assembly == null) + throw new ArgumentNullException(nameof(assembly)); + + const string TargetFrameworkAttributeName = "System.Runtime.Versioning.TargetFrameworkAttribute"; + var reader = assembly.GetMetadataReader(); + + foreach (var h in reader.GetCustomAttributes(Handle.AssemblyDefinition)) + { + try + { + var attribute = reader.GetCustomAttribute(h); + if (attribute.GetAttributeType(reader).GetFullTypeName(reader).ToString() != TargetFrameworkAttributeName) + continue; + var blobReader = reader.GetBlobReader(attribute.Value); + if (blobReader.ReadUInt16() == 0x0001) + { + return blobReader.ReadSerializedString(); + } + } + catch (BadImageFormatException) + { + // ignore malformed attributes + } + } + + foreach (var h in reader.AssemblyReferences) + { + try + { + var r = reader.GetAssemblyReference(h); + if (r.PublicKeyOrToken.IsNil) + continue; + string version; + switch (reader.GetString(r.Name)) + { + case "netstandard": + version = r.Version.ToString(3); + return $".NETStandard,Version=v{version}"; + case "System.Runtime": + // System.Runtime.dll uses the following scheme: + // 4.2.0 => .NET Core 2.0 + // 4.2.1 => .NET Core 2.1 / 3.0 + // 4.2.2 => .NET Core 3.1 + if (r.Version >= new Version(4, 2, 0)) + { + version = "2.0"; + if (r.Version >= new Version(4, 2, 1)) + { + version = "3.0"; + } + if (r.Version >= new Version(4, 2, 2)) + { + version = "3.1"; + } + return $".NETCoreApp,Version=v{version}"; + } + else + { + continue; + } + case "mscorlib": + version = r.Version.ToString(2); + return $".NETFramework,Version=v{version}"; + } + } + catch (BadImageFormatException) + { + // ignore malformed references + } + } + + // Optionally try to detect target version through assembly path as a fallback (use case: reference assemblies) + if (assemblyPath != null) + { + /* + * Detected path patterns (examples): + * + * - .NETFramework -> C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.6.1\mscorlib.dll + * - .NETCore -> C:\Program Files\dotnet\sdk\NuGetFallbackFolder\microsoft.netcore.app\2.1.0\ref\netcoreapp2.1\System.Console.dll + * - .NETStandard -> C:\Program Files\dotnet\sdk\NuGetFallbackFolder\netstandard.library\2.0.3\build\netstandard2.0\ref\netstandard.dll + */ + var pathMatch = Regex.Match(assemblyPath, PathPattern, + RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.ExplicitCapture); + if (pathMatch.Success) + { + var type = pathMatch.Groups["type"].Value; + var version = pathMatch.Groups["version"].Value; + if (string.IsNullOrEmpty(version)) + version = reader.MetadataVersion; + + if (type == "Microsoft.NET" || type == ".NETFramework") + { + return $".NETFramework,Version=v{version.TrimStart('v').Substring(0, 3)}"; + } + else if (type.IndexOf("netcore", StringComparison.OrdinalIgnoreCase) >= 0) + { + return $".NETCoreApp,Version=v{version}"; + } + else if (type.IndexOf("netstandard", StringComparison.OrdinalIgnoreCase) >= 0) + { + return $".NETStandard,Version=v{version}"; + } + } + else + { + return $".NETFramework,Version={reader.MetadataVersion.Substring(0, 4)}"; + } + } + + return string.Empty; + } + + public static bool IsReferenceAssembly(this PEFile assembly) + { + return IsReferenceAssembly(assembly.Reader, assembly.FileName); + } + + public static bool IsReferenceAssembly(this PEReader assembly, string assemblyPath) + { + if (assembly == null) + throw new ArgumentNullException(nameof(assembly)); + + var metadata = assembly.GetMetadataReader(); + if (metadata.GetCustomAttributes(Handle.AssemblyDefinition).HasKnownAttribute(metadata, KnownAttribute.ReferenceAssembly)) + return true; + + // Try to detect reference assembly through specific path pattern + var refPathMatch = Regex.Match(assemblyPath, RefPathPattern, RegexOptions.IgnoreCase | RegexOptions.Compiled); + return refPathMatch.Success; + } + } + + public class ReferenceLoadInfo + { + readonly Dictionary loadedAssemblyReferences = new Dictionary(); + + public void AddMessage(string fullName, MessageKind kind, string message) + { + lock (loadedAssemblyReferences) + { + if (!loadedAssemblyReferences.TryGetValue(fullName, out var referenceInfo)) + { + referenceInfo = new UnresolvedAssemblyNameReference(fullName); + loadedAssemblyReferences.Add(fullName, referenceInfo); + } + referenceInfo.Messages.Add((kind, message)); + } + } + + public void AddMessageOnce(string fullName, MessageKind kind, string message) + { + lock (loadedAssemblyReferences) + { + if (!loadedAssemblyReferences.TryGetValue(fullName, out var referenceInfo)) + { + referenceInfo = new UnresolvedAssemblyNameReference(fullName); + loadedAssemblyReferences.Add(fullName, referenceInfo); + referenceInfo.Messages.Add((kind, message)); + } + else + { + var lastMsg = referenceInfo.Messages.LastOrDefault(); + if (kind != lastMsg.Item1 && message != lastMsg.Item2) + referenceInfo.Messages.Add((kind, message)); + } + } + } + + public bool TryGetInfo(string fullName, out UnresolvedAssemblyNameReference info) + { + lock (loadedAssemblyReferences) + { + return loadedAssemblyReferences.TryGetValue(fullName, out info); + } + } + + public IReadOnlyList Entries { + get { + lock (loadedAssemblyReferences) + { + return loadedAssemblyReferences.Values.ToList(); + } + } + } + + public bool HasErrors { + get { + lock (loadedAssemblyReferences) + { + return loadedAssemblyReferences.Any(i => i.Value.HasErrors); + } + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/EnumUnderlyingTypeResolveException.cs b/src/ICSharpCode.Decompiler/Metadata/EnumUnderlyingTypeResolveException.cs new file mode 100644 index 0000000..b7be7e9 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/EnumUnderlyingTypeResolveException.cs @@ -0,0 +1,45 @@ +// Copyright (c) 2018 Siegfried Pammer +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Runtime.Serialization; + +namespace ICSharpCode.Decompiler.Metadata +{ + [Serializable] + public class EnumUnderlyingTypeResolveException : Exception + { + public EnumUnderlyingTypeResolveException() { } + public EnumUnderlyingTypeResolveException(string message) : base(message) { } + public EnumUnderlyingTypeResolveException(string message, Exception inner) : base(message, inner) { } + protected EnumUnderlyingTypeResolveException( + SerializationInfo info, + StreamingContext context) : base(info, context) { } + } + + [Serializable] + public class PEFileNotSupportedException : Exception + { + public PEFileNotSupportedException() { } + public PEFileNotSupportedException(string message) : base(message) { } + public PEFileNotSupportedException(string message, Exception inner) : base(message, inner) { } + protected PEFileNotSupportedException( + SerializationInfo info, + StreamingContext context) : base(info, context) { } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/ILOpCodes.cs b/src/ICSharpCode.Decompiler/Metadata/ILOpCodes.cs new file mode 100644 index 0000000..6a818d4 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/ILOpCodes.cs @@ -0,0 +1,29 @@ +// Copyright (c) 2014 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +namespace ICSharpCode.Decompiler.Metadata +{ + + static partial class ILOpCodeExtensions + { + // We use a byte array instead of an enum array because it can be initialized more efficiently + static readonly byte[] operandTypes = { (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.ShortVariable, (byte)OperandType.ShortVariable, (byte)OperandType.ShortVariable, (byte)OperandType.ShortVariable, (byte)OperandType.ShortVariable, (byte)OperandType.ShortVariable, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.ShortI, (byte)OperandType.I, (byte)OperandType.I8, (byte)OperandType.ShortR, (byte)OperandType.R, 255, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.Method, (byte)OperandType.Method, (byte)OperandType.Sig, (byte)OperandType.None, (byte)OperandType.ShortBrTarget, (byte)OperandType.ShortBrTarget, (byte)OperandType.ShortBrTarget, (byte)OperandType.ShortBrTarget, (byte)OperandType.ShortBrTarget, (byte)OperandType.ShortBrTarget, (byte)OperandType.ShortBrTarget, (byte)OperandType.ShortBrTarget, (byte)OperandType.ShortBrTarget, (byte)OperandType.ShortBrTarget, (byte)OperandType.ShortBrTarget, (byte)OperandType.ShortBrTarget, (byte)OperandType.ShortBrTarget, (byte)OperandType.BrTarget, (byte)OperandType.BrTarget, (byte)OperandType.BrTarget, (byte)OperandType.BrTarget, (byte)OperandType.BrTarget, (byte)OperandType.BrTarget, (byte)OperandType.BrTarget, (byte)OperandType.BrTarget, (byte)OperandType.BrTarget, (byte)OperandType.BrTarget, (byte)OperandType.BrTarget, (byte)OperandType.BrTarget, (byte)OperandType.BrTarget, (byte)OperandType.Switch, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.Method, (byte)OperandType.Type, (byte)OperandType.Type, (byte)OperandType.String, (byte)OperandType.Method, (byte)OperandType.Type, (byte)OperandType.Type, (byte)OperandType.None, 255, 255, (byte)OperandType.Type, (byte)OperandType.None, (byte)OperandType.Field, (byte)OperandType.Field, (byte)OperandType.Field, (byte)OperandType.Field, (byte)OperandType.Field, (byte)OperandType.Field, (byte)OperandType.Type, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.Type, (byte)OperandType.Type, (byte)OperandType.None, (byte)OperandType.Type, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.Type, (byte)OperandType.Type, (byte)OperandType.Type, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, 255, 255, 255, 255, 255, 255, 255, (byte)OperandType.Type, (byte)OperandType.None, 255, 255, (byte)OperandType.Type, 255, 255, 255, 255, 255, 255, 255, 255, 255, (byte)OperandType.Tok, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.BrTarget, (byte)OperandType.ShortBrTarget, (byte)OperandType.None, (byte)OperandType.None, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.Method, (byte)OperandType.Method, 255, (byte)OperandType.Variable, (byte)OperandType.Variable, (byte)OperandType.Variable, (byte)OperandType.Variable, (byte)OperandType.Variable, (byte)OperandType.Variable, (byte)OperandType.None, 255, (byte)OperandType.None, (byte)OperandType.ShortI, (byte)OperandType.None, (byte)OperandType.None, (byte)OperandType.Type, (byte)OperandType.Type, (byte)OperandType.None, (byte)OperandType.None, 255, (byte)OperandType.None, 255, (byte)OperandType.Type, (byte)OperandType.None, (byte)OperandType.None, }; + + static readonly string[] operandNames = { "nop", "break", "ldarg.0", "ldarg.1", "ldarg.2", "ldarg.3", "ldloc.0", "ldloc.1", "ldloc.2", "ldloc.3", "stloc.0", "stloc.1", "stloc.2", "stloc.3", "ldarg.s", "ldarga.s", "starg.s", "ldloc.s", "ldloca.s", "stloc.s", "ldnull", "ldc.i4.m1", "ldc.i4.0", "ldc.i4.1", "ldc.i4.2", "ldc.i4.3", "ldc.i4.4", "ldc.i4.5", "ldc.i4.6", "ldc.i4.7", "ldc.i4.8", "ldc.i4.s", "ldc.i4", "ldc.i8", "ldc.r4", "ldc.r8", "", "dup", "pop", "jmp", "call", "calli", "ret", "br.s", "brfalse.s", "brtrue.s", "beq.s", "bge.s", "bgt.s", "ble.s", "blt.s", "bne.un.s", "bge.un.s", "bgt.un.s", "ble.un.s", "blt.un.s", "br", "brfalse", "brtrue", "beq", "bge", "bgt", "ble", "blt", "bne.un", "bge.un", "bgt.un", "ble.un", "blt.un", "switch", "ldind.i1", "ldind.u1", "ldind.i2", "ldind.u2", "ldind.i4", "ldind.u4", "ldind.i8", "ldind.i", "ldind.r4", "ldind.r8", "ldind.ref", "stind.ref", "stind.i1", "stind.i2", "stind.i4", "stind.i8", "stind.r4", "stind.r8", "add", "sub", "mul", "div", "div.un", "rem", "rem.un", "and", "or", "xor", "shl", "shr", "shr.un", "neg", "not", "conv.i1", "conv.i2", "conv.i4", "conv.i8", "conv.r4", "conv.r8", "conv.u4", "conv.u8", "callvirt", "cpobj", "ldobj", "ldstr", "newobj", "castclass", "isinst", "conv.r.un", "", "", "unbox", "throw", "ldfld", "ldflda", "stfld", "ldsfld", "ldsflda", "stsfld", "stobj", "conv.ovf.i1.un", "conv.ovf.i2.un", "conv.ovf.i4.un", "conv.ovf.i8.un", "conv.ovf.u1.un", "conv.ovf.u2.un", "conv.ovf.u4.un", "conv.ovf.u8.un", "conv.ovf.i.un", "conv.ovf.u.un", "box", "newarr", "ldlen", "ldelema", "ldelem.i1", "ldelem.u1", "ldelem.i2", "ldelem.u2", "ldelem.i4", "ldelem.u4", "ldelem.i8", "ldelem.i", "ldelem.r4", "ldelem.r8", "ldelem.ref", "stelem.i", "stelem.i1", "stelem.i2", "stelem.i4", "stelem.i8", "stelem.r4", "stelem.r8", "stelem.ref", "ldelem", "stelem", "unbox.any", "", "", "", "", "", "", "", "", "", "", "", "", "", "conv.ovf.i1", "conv.ovf.u1", "conv.ovf.i2", "conv.ovf.u2", "conv.ovf.i4", "conv.ovf.u4", "conv.ovf.i8", "conv.ovf.u8", "", "", "", "", "", "", "", "refanyval", "ckfinite", "", "", "mkrefany", "", "", "", "", "", "", "", "", "", "ldtoken", "conv.u2", "conv.u1", "conv.i", "conv.ovf.i", "conv.ovf.u", "add.ovf", "add.ovf.un", "mul.ovf", "mul.ovf.un", "sub.ovf", "sub.ovf.un", "endfinally", "leave", "leave.s", "stind.i", "conv.u", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "prefix7", "prefix6", "prefix5", "prefix4", "prefix3", "prefix2", "prefix1", "prefixref", "arglist", "ceq", "cgt", "cgt.un", "clt", "clt.un", "ldftn", "ldvirtftn", "", "ldarg", "ldarga", "starg", "ldloc", "ldloca", "stloc", "localloc", "", "endfilter", "unaligned.", "volatile.", "tail.", "initobj", "constrained.", "cpblk", "initblk", "", "rethrow", "", "sizeof", "refanytype", "readonly.", }; + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/ILOpCodes.tt b/src/ICSharpCode.Decompiler/Metadata/ILOpCodes.tt new file mode 100644 index 0000000..45488d6 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/ILOpCodes.tt @@ -0,0 +1,64 @@ +// Copyright (c) 2014 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +<#@ template debug="false" hostspecific="false" language="C#" #> +<#@ assembly name="System.Core" #> +<#@ import namespace="System.Linq" #> +<#@ import namespace="System.Text" #> +<#@ import namespace="System.Collections.Generic" #> +<#@ import namespace="System.Reflection.Metadata" #> +<#@ import namespace="System.Reflection.Emit" #> +<#@ output extension=".cs" #> +using System; +using System.Collections.Generic; +using System.Reflection.Metadata; +<# + var operandTypes = Enumerable.Repeat((OperandType)0xff, 0x11f).ToArray(); + var operandNames = new string[0x11f]; +#> +namespace ICSharpCode.Decompiler.Metadata +{ +<# + foreach (var field in typeof(OpCodes).GetFields()) { + var opCode = (OpCode)field.GetValue(null); + ushort index = (ushort)(((opCode.Value & 0x200) >> 1) | (opCode.Value & 0xff)); + operandTypes[index] = opCode.OperandType; + operandNames[index] = opCode.Name; + } #> + + static partial class ILOpCodeExtensions + { + // We use a byte array instead of an enum array because it can be initialized more efficiently + static readonly byte[] operandTypes = { <# + foreach (var operandType in operandTypes) { + if ((byte)operandType == 255) { + Write("255, "); + } else { + string operandTypeName = operandType.ToString().Replace("Inline", "").Replace("Var", "Variable"); + Write("(byte)OperandType." + operandTypeName + ", "); + } + } + #> }; + + static readonly string[] operandNames = { <# + foreach (var operandName in operandNames) { + Write("\"" + operandName + "\", "); + } + #> }; + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/LightJson/JsonArray.cs b/src/ICSharpCode.Decompiler/Metadata/LightJson/JsonArray.cs new file mode 100644 index 0000000..df1c02c --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/LightJson/JsonArray.cs @@ -0,0 +1,187 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. + +namespace LightJson +{ + using System; + using System.Collections.Generic; + using System.Diagnostics; + using System.Diagnostics.CodeAnalysis; + + /// + /// Represents an ordered collection of JsonValues. + /// + [DebuggerDisplay("Count = {Count}")] + [DebuggerTypeProxy(typeof(JsonArrayDebugView))] + internal sealed class JsonArray : IEnumerable + { + private IList items; + + /// + /// Initializes a new instance of the class. + /// + public JsonArray() + { + this.items = new List(); + } + + /// + /// Initializes a new instance of the class, adding the given values to the collection. + /// + /// The values to be added to this collection. + public JsonArray(params JsonValue[] values) + : this() + { + if (values == null) + { + throw new ArgumentNullException(nameof(values)); + } + + foreach (var value in values) + { + this.items.Add(value); + } + } + + /// + /// Gets the number of values in this collection. + /// + /// The number of values in this collection. + public int Count { + get { + return this.items.Count; + } + } + + /// + /// Gets or sets the value at the given index. + /// + /// The zero-based index of the value to get or set. + /// + /// The getter will return JsonValue.Null if the given index is out of range. + /// + public JsonValue this[int index] { + get { + if (index >= 0 && index < this.items.Count) + { + return this.items[index]; + } + else + { + return JsonValue.Null; + } + } + + set { + this.items[index] = value; + } + } + + /// + /// Adds the given value to this collection. + /// + /// The value to be added. + /// Returns this collection. + public JsonArray Add(JsonValue value) + { + this.items.Add(value); + return this; + } + + /// + /// Inserts the given value at the given index in this collection. + /// + /// The index where the given value will be inserted. + /// The value to be inserted into this collection. + /// Returns this collection. + public JsonArray Insert(int index, JsonValue value) + { + this.items.Insert(index, value); + return this; + } + + /// + /// Removes the value at the given index. + /// + /// The index of the value to be removed. + /// Return this collection. + public JsonArray Remove(int index) + { + this.items.RemoveAt(index); + return this; + } + + /// + /// Clears the contents of this collection. + /// + /// Returns this collection. + public JsonArray Clear() + { + this.items.Clear(); + return this; + } + + /// + /// Determines whether the given item is in the JsonArray. + /// + /// The item to locate in the JsonArray. + /// Returns true if the item is found; otherwise, false. + public bool Contains(JsonValue item) + { + return this.items.Contains(item); + } + + /// + /// Determines the index of the given item in this JsonArray. + /// + /// The item to locate in this JsonArray. + /// The index of the item, if found. Otherwise, returns -1. + public int IndexOf(JsonValue item) + { + return this.items.IndexOf(item); + } + + /// + /// Returns an enumerator that iterates through the collection. + /// + /// The enumerator that iterates through the collection. + public IEnumerator GetEnumerator() + { + return this.items.GetEnumerator(); + } + + /// + /// Returns an enumerator that iterates through the collection. + /// + /// The enumerator that iterates through the collection. + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return this.GetEnumerator(); + } + + [ExcludeFromCodeCoverage] + private class JsonArrayDebugView + { + private JsonArray jsonArray; + + public JsonArrayDebugView(JsonArray jsonArray) + { + this.jsonArray = jsonArray; + } + + [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)] + public JsonValue[] Items { + get { + var items = new JsonValue[this.jsonArray.Count]; + + for (var i = 0; i < this.jsonArray.Count; i += 1) + { + items[i] = this.jsonArray[i]; + } + + return items; + } + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/LightJson/JsonObject.cs b/src/ICSharpCode.Decompiler/Metadata/LightJson/JsonObject.cs new file mode 100644 index 0000000..ddda8a1 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/LightJson/JsonObject.cs @@ -0,0 +1,252 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. + +namespace LightJson +{ + using System.Collections.Generic; + using System.Diagnostics; + using System.Diagnostics.CodeAnalysis; + + /// + /// Represents a key-value pair collection of JsonValue objects. + /// + [DebuggerDisplay("Count = {Count}")] + [DebuggerTypeProxy(typeof(JsonObjectDebugView))] + internal sealed class JsonObject : IEnumerable>, IEnumerable + { + private IDictionary properties; + + /// + /// Initializes a new instance of the class. + /// + public JsonObject() + { + this.properties = new Dictionary(); + } + + /// + /// Gets the number of properties in this JsonObject. + /// + /// The number of properties in this JsonObject. + public int Count { + get { + return this.properties.Count; + } + } + + /// + /// Gets or sets the property with the given key. + /// + /// The key of the property to get or set. + /// + /// The getter will return JsonValue.Null if the given key is not associated with any value. + /// + public JsonValue this[string key] { + get { + JsonValue value; + + if (this.properties.TryGetValue(key, out value)) + { + return value; + } + else + { + return JsonValue.Null; + } + } + + set { + this.properties[key] = value; + } + } + + /// + /// Adds a key with a null value to this collection. + /// + /// The key of the property to be added. + /// Returns this JsonObject. + /// The that was added. + public JsonObject Add(string key) + { + return this.Add(key, JsonValue.Null); + } + + /// + /// Adds a value associated with a key to this collection. + /// + /// The key of the property to be added. + /// The value of the property to be added. + /// Returns this JsonObject. + public JsonObject Add(string key, JsonValue value) + { + this.properties.Add(key, value); + return this; + } + + /// + /// Removes a property with the given key. + /// + /// The key of the property to be removed. + /// + /// Returns true if the given key is found and removed; otherwise, false. + /// + public bool Remove(string key) + { + return this.properties.Remove(key); + } + + /// + /// Clears the contents of this collection. + /// + /// Returns this JsonObject. + public JsonObject Clear() + { + this.properties.Clear(); + return this; + } + + /// + /// Changes the key of one of the items in the collection. + /// + /// + /// This method has no effects if the oldKey does not exists. + /// If the newKey already exists, the value will be overwritten. + /// + /// The name of the key to be changed. + /// The new name of the key. + /// Returns this JsonObject. + public JsonObject Rename(string oldKey, string newKey) + { + if (oldKey == newKey) + { + // Renaming to the same name just does nothing + return this; + } + + JsonValue value; + + if (this.properties.TryGetValue(oldKey, out value)) + { + this[newKey] = value; + this.Remove(oldKey); + } + + return this; + } + + /// + /// Determines whether this collection contains an item assosiated with the given key. + /// + /// The key to locate in this collection. + /// Returns true if the key is found; otherwise, false. + public bool ContainsKey(string key) + { + return this.properties.ContainsKey(key); + } + + /// + /// Determines whether this collection contains the given JsonValue. + /// + /// The value to locate in this collection. + /// Returns true if the value is found; otherwise, false. + public bool Contains(JsonValue value) + { + return this.properties.Values.Contains(value); + } + + /// + /// Returns an enumerator that iterates through this collection. + /// + /// The enumerator that iterates through this collection. + public IEnumerator> GetEnumerator() + { + return this.properties.GetEnumerator(); + } + + /// + /// Returns an enumerator that iterates through this collection. + /// + /// The enumerator that iterates through this collection. + IEnumerator IEnumerable.GetEnumerator() + { + return this.properties.Values.GetEnumerator(); + } + + /// + /// Returns an enumerator that iterates through this collection. + /// + /// The enumerator that iterates through this collection. + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return this.GetEnumerator(); + } + + [ExcludeFromCodeCoverage] + private class JsonObjectDebugView + { + private JsonObject jsonObject; + + public JsonObjectDebugView(JsonObject jsonObject) + { + this.jsonObject = jsonObject; + } + + [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)] + public KeyValuePair[] Keys { + get { + var keys = new KeyValuePair[this.jsonObject.Count]; + + var i = 0; + foreach (var property in this.jsonObject) + { + keys[i] = new KeyValuePair(property.Key, property.Value); + i += 1; + } + + return keys; + } + } + + [DebuggerDisplay("{value.ToString(),nq}", Name = "{key}", Type = "JsonValue({Type})")] + public class KeyValuePair + { + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private string key; + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private JsonValue value; + + public KeyValuePair(string key, JsonValue value) + { + this.key = key; + this.value = value; + } + + [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)] + public object View { + get { + if (this.value.IsJsonObject) + { + return (JsonObject)this.value; + } + else if (this.value.IsJsonArray) + { + return (JsonArray)this.value; + } + else + { + return this.value; + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private JsonValueType Type { + get { + return this.value.Type; + } + } + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/LightJson/JsonValue.cs b/src/ICSharpCode.Decompiler/Metadata/LightJson/JsonValue.cs new file mode 100644 index 0000000..c79ac34 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/LightJson/JsonValue.cs @@ -0,0 +1,862 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. + +namespace LightJson +{ + using System; + using System.Collections.Generic; + using System.Diagnostics; + using System.Diagnostics.CodeAnalysis; + using System.Globalization; + + using LightJson.Serialization; + + /// + /// A wrapper object that contains a valid JSON value. + /// + [DebuggerDisplay("{ToString(),nq}", Type = "JsonValue({Type})")] + [DebuggerTypeProxy(typeof(JsonValueDebugView))] + internal struct JsonValue + { + /// + /// Represents a null JsonValue. + /// + public static readonly JsonValue Null = new JsonValue(JsonValueType.Null, default(double), null); + + private readonly JsonValueType type; + private readonly object reference; + private readonly double value; + + /// + /// Initializes a new instance of the struct, representing a Boolean value. + /// + /// The value to be wrapped. + public JsonValue(bool? value) + { + if (value.HasValue) + { + this.reference = null; + + this.type = JsonValueType.Boolean; + + this.value = value.Value ? 1 : 0; + } + else + { + this = JsonValue.Null; + } + } + + /// + /// Initializes a new instance of the struct, representing a Number value. + /// + /// The value to be wrapped. + public JsonValue(double? value) + { + if (value.HasValue) + { + this.reference = null; + + this.type = JsonValueType.Number; + + this.value = value.Value; + } + else + { + this = JsonValue.Null; + } + } + + /// + /// Initializes a new instance of the struct, representing a String value. + /// + /// The value to be wrapped. + public JsonValue(string value) + { + if (value != null) + { + this.value = default(double); + + this.type = JsonValueType.String; + + this.reference = value; + } + else + { + this = JsonValue.Null; + } + } + + /// + /// Initializes a new instance of the struct, representing a JsonObject. + /// + /// The value to be wrapped. + public JsonValue(JsonObject value) + { + if (value != null) + { + this.value = default(double); + + this.type = JsonValueType.Object; + + this.reference = value; + } + else + { + this = JsonValue.Null; + } + } + + /// + /// Initializes a new instance of the struct, representing a Array reference value. + /// + /// The value to be wrapped. + public JsonValue(JsonArray value) + { + if (value != null) + { + this.value = default(double); + + this.type = JsonValueType.Array; + + this.reference = value; + } + else + { + this = JsonValue.Null; + } + } + + /// + /// Initializes a new instance of the struct. + /// + /// The Json type of the JsonValue. + /// + /// The internal value of the JsonValue. + /// This is used when the Json type is Number or Boolean. + /// + /// + /// The internal value reference of the JsonValue. + /// This value is used when the Json type is String, JsonObject, or JsonArray. + /// + private JsonValue(JsonValueType type, double value, object reference) + { + this.type = type; + this.value = value; + this.reference = reference; + } + + /// + /// Gets the type of this JsonValue. + /// + /// The type of this JsonValue. + public JsonValueType Type { + get { + return this.type; + } + } + + /// + /// Gets a value indicating whether this JsonValue is Null. + /// + /// A value indicating whether this JsonValue is Null. + public bool IsNull { + get { + return this.Type == JsonValueType.Null; + } + } + + /// + /// Gets a value indicating whether this JsonValue is a Boolean. + /// + /// A value indicating whether this JsonValue is a Boolean. + public bool IsBoolean { + get { + return this.Type == JsonValueType.Boolean; + } + } + + /// + /// Gets a value indicating whether this JsonValue is an Integer. + /// + /// A value indicating whether this JsonValue is an Integer. + public bool IsInteger { + get { + if (!this.IsNumber) + { + return false; + } + + var value = this.value; + return unchecked((int)value) == value; + } + } + + /// + /// Gets a value indicating whether this JsonValue is a Number. + /// + /// A value indicating whether this JsonValue is a Number. + public bool IsNumber { + get { + return this.Type == JsonValueType.Number; + } + } + + /// + /// Gets a value indicating whether this JsonValue is a String. + /// + /// A value indicating whether this JsonValue is a String. + public bool IsString { + get { + return this.Type == JsonValueType.String; + } + } + + /// + /// Gets a value indicating whether this JsonValue is a JsonObject. + /// + /// A value indicating whether this JsonValue is a JsonObject. + public bool IsJsonObject { + get { + return this.Type == JsonValueType.Object; + } + } + + /// + /// Gets a value indicating whether this JsonValue is a JsonArray. + /// + /// A value indicating whether this JsonValue is a JsonArray. + public bool IsJsonArray { + get { + return this.Type == JsonValueType.Array; + } + } + + /// + /// Gets a value indicating whether this JsonValue represents a DateTime. + /// + /// A value indicating whether this JsonValue represents a DateTime. + public bool IsDateTime { + get { + return this.AsDateTime != null; + } + } + + /// + /// Gets a value indicating whether this value is true or false. + /// + /// This value as a Boolean type. + public bool AsBoolean { + get { + switch (this.Type) + { + case JsonValueType.Boolean: + return this.value == 1; + + case JsonValueType.Number: + return this.value != 0; + + case JsonValueType.String: + return (string)this.reference != string.Empty; + + case JsonValueType.Object: + case JsonValueType.Array: + return true; + + default: + return false; + } + } + } + + /// + /// Gets this value as an Integer type. + /// + /// This value as an Integer type. + public int AsInteger { + get { + var value = this.AsNumber; + + // Prevent overflow if the value doesn't fit. + if (value >= int.MaxValue) + { + return int.MaxValue; + } + + if (value <= int.MinValue) + { + return int.MinValue; + } + + return (int)value; + } + } + + /// + /// Gets this value as a Number type. + /// + /// This value as a Number type. + public double AsNumber { + get { + switch (this.Type) + { + case JsonValueType.Boolean: + return (this.value == 1) + ? 1 + : 0; + + case JsonValueType.Number: + return this.value; + + case JsonValueType.String: + double number; + if (double.TryParse((string)this.reference, NumberStyles.Float, CultureInfo.InvariantCulture, out number)) + { + return number; + } + else + { + goto default; + } + + default: + return 0; + } + } + } + + /// + /// Gets this value as a String type. + /// + /// This value as a String type. + public string AsString { + get { + switch (this.Type) + { + case JsonValueType.Boolean: + return (this.value == 1) + ? "true" + : "false"; + + case JsonValueType.Number: + return this.value.ToString(CultureInfo.InvariantCulture); + + case JsonValueType.String: + return (string)this.reference; + + default: + return null; + } + } + } + + /// + /// Gets this value as an JsonObject. + /// + /// This value as an JsonObject. + public JsonObject AsJsonObject { + get { + return this.IsJsonObject + ? (JsonObject)this.reference + : null; + } + } + + /// + /// Gets this value as an JsonArray. + /// + /// This value as an JsonArray. + public JsonArray AsJsonArray { + get { + return this.IsJsonArray + ? (JsonArray)this.reference + : null; + } + } + + /// + /// Gets this value as a system.DateTime. + /// + /// This value as a system.DateTime. + public DateTime? AsDateTime { + get { + DateTime value; + + if (this.IsString && DateTime.TryParse((string)this.reference, out value)) + { + return value; + } + else + { + return null; + } + } + } + + /// + /// Gets this (inner) value as a System.object. + /// + /// This (inner) value as a System.object. + public object AsObject { + get { + switch (this.Type) + { + case JsonValueType.Boolean: + case JsonValueType.Number: + return this.value; + + case JsonValueType.String: + case JsonValueType.Object: + case JsonValueType.Array: + return this.reference; + + default: + return null; + } + } + } + + /// + /// Gets or sets the value associated with the specified key. + /// + /// The key of the value to get or set. + /// + /// Thrown when this JsonValue is not a JsonObject. + /// + public JsonValue this[string key] { + get { + if (this.IsJsonObject) + { + return ((JsonObject)this.reference)[key]; + } + else + { + throw new InvalidOperationException("This value does not represent a JsonObject."); + } + } + + set { + if (this.IsJsonObject) + { + ((JsonObject)this.reference)[key] = value; + } + else + { + throw new InvalidOperationException("This value does not represent a JsonObject."); + } + } + } + + /// + /// Gets or sets the value at the specified index. + /// + /// The zero-based index of the value to get or set. + /// + /// Thrown when this JsonValue is not a JsonArray + /// + public JsonValue this[int index] { + get { + if (this.IsJsonArray) + { + return ((JsonArray)this.reference)[index]; + } + else + { + throw new InvalidOperationException("This value does not represent a JsonArray."); + } + } + + set { + if (this.IsJsonArray) + { + ((JsonArray)this.reference)[index] = value; + } + else + { + throw new InvalidOperationException("This value does not represent a JsonArray."); + } + } + } + + /// + /// Converts the given nullable boolean into a JsonValue. + /// + /// The value to be converted. + public static implicit operator JsonValue(bool? value) + { + return new JsonValue(value); + } + + /// + /// Converts the given nullable double into a JsonValue. + /// + /// The value to be converted. + public static implicit operator JsonValue(double? value) + { + return new JsonValue(value); + } + + /// + /// Converts the given string into a JsonValue. + /// + /// The value to be converted. + public static implicit operator JsonValue(string value) + { + return new JsonValue(value); + } + + /// + /// Converts the given JsonObject into a JsonValue. + /// + /// The value to be converted. + public static implicit operator JsonValue(JsonObject value) + { + return new JsonValue(value); + } + + /// + /// Converts the given JsonArray into a JsonValue. + /// + /// The value to be converted. + public static implicit operator JsonValue(JsonArray value) + { + return new JsonValue(value); + } + + /// + /// Converts the given DateTime? into a JsonValue. + /// + /// + /// The DateTime value will be stored as a string using ISO 8601 format, + /// since JSON does not define a DateTime type. + /// + /// The value to be converted. + public static implicit operator JsonValue(DateTime? value) + { + if (value == null) + { + return JsonValue.Null; + } + + return new JsonValue(value.Value.ToString("o")); + } + + /// + /// Converts the given JsonValue into an Int. + /// + /// The JsonValue to be converted. + public static explicit operator int(JsonValue jsonValue) + { + if (jsonValue.IsInteger) + { + return jsonValue.AsInteger; + } + else + { + return 0; + } + } + + /// + /// Converts the given JsonValue into a nullable Int. + /// + /// The JsonValue to be converted. + /// + /// Throws System.InvalidCastException when the inner value type of the + /// JsonValue is not the desired type of the conversion. + /// + public static explicit operator int?(JsonValue jsonValue) + { + if (jsonValue.IsNull) + { + return null; + } + else + { + return (int)jsonValue; + } + } + + /// + /// Converts the given JsonValue into a Bool. + /// + /// The JsonValue to be converted. + public static explicit operator bool(JsonValue jsonValue) + { + if (jsonValue.IsBoolean) + { + return jsonValue.value == 1; + } + else + { + return false; + } + } + + /// + /// Converts the given JsonValue into a nullable Bool. + /// + /// The JsonValue to be converted. + /// + /// Throws System.InvalidCastException when the inner value type of the + /// JsonValue is not the desired type of the conversion. + /// + public static explicit operator bool?(JsonValue jsonValue) + { + if (jsonValue.IsNull) + { + return null; + } + else + { + return (bool)jsonValue; + } + } + + /// + /// Converts the given JsonValue into a Double. + /// + /// The JsonValue to be converted. + public static explicit operator double(JsonValue jsonValue) + { + if (jsonValue.IsNumber) + { + return jsonValue.value; + } + else + { + return double.NaN; + } + } + + /// + /// Converts the given JsonValue into a nullable Double. + /// + /// The JsonValue to be converted. + /// + /// Throws System.InvalidCastException when the inner value type of the + /// JsonValue is not the desired type of the conversion. + /// + public static explicit operator double?(JsonValue jsonValue) + { + if (jsonValue.IsNull) + { + return null; + } + else + { + return (double)jsonValue; + } + } + + /// + /// Converts the given JsonValue into a String. + /// + /// The JsonValue to be converted. + public static explicit operator string(JsonValue jsonValue) + { + if (jsonValue.IsString || jsonValue.IsNull) + { + return jsonValue.reference as string; + } + else + { + return null; + } + } + + /// + /// Converts the given JsonValue into a JsonObject. + /// + /// The JsonValue to be converted. + public static explicit operator JsonObject(JsonValue jsonValue) + { + if (jsonValue.IsJsonObject || jsonValue.IsNull) + { + return jsonValue.reference as JsonObject; + } + else + { + return null; + } + } + + /// + /// Converts the given JsonValue into a JsonArray. + /// + /// The JsonValue to be converted. + public static explicit operator JsonArray(JsonValue jsonValue) + { + if (jsonValue.IsJsonArray || jsonValue.IsNull) + { + return jsonValue.reference as JsonArray; + } + else + { + return null; + } + } + + /// + /// Converts the given JsonValue into a DateTime. + /// + /// The JsonValue to be converted. + public static explicit operator DateTime(JsonValue jsonValue) + { + var dateTime = jsonValue.AsDateTime; + + if (dateTime.HasValue) + { + return dateTime.Value; + } + else + { + return DateTime.MinValue; + } + } + + /// + /// Converts the given JsonValue into a nullable DateTime. + /// + /// The JsonValue to be converted. + public static explicit operator DateTime?(JsonValue jsonValue) + { + if (jsonValue.IsDateTime || jsonValue.IsNull) + { + return jsonValue.AsDateTime; + } + else + { + return null; + } + } + + /// + /// Returns a value indicating whether the two given JsonValues are equal. + /// + /// First JsonValue to compare. + /// Second JsonValue to compare. + public static bool operator ==(JsonValue a, JsonValue b) + { + return (a.Type == b.Type) + && (a.value == b.value) + && Equals(a.reference, b.reference); + } + + /// + /// Returns a value indicating whether the two given JsonValues are unequal. + /// + /// First JsonValue to compare. + /// Second JsonValue to compare. + public static bool operator !=(JsonValue a, JsonValue b) + { + return !(a == b); + } + + /// + /// Returns a JsonValue by parsing the given string. + /// + /// The JSON-formatted string to be parsed. + /// The representing the parsed text. + public static JsonValue Parse(string text) + { + return JsonReader.Parse(text); + } + + /// + public override bool Equals(object obj) + { + if (obj == null) + { + return this.IsNull; + } + + var jsonValue = obj as JsonValue?; + if (jsonValue == null) + { + return false; + } + else + { + return this == jsonValue.Value; + } + } + + /// + public override int GetHashCode() + { + if (this.IsNull) + { + return this.Type.GetHashCode(); + } + else + { + return this.Type.GetHashCode() + ^ this.value.GetHashCode() + ^ EqualityComparer.Default.GetHashCode(this.reference); + } + } + + [ExcludeFromCodeCoverage] + private class JsonValueDebugView + { + private JsonValue jsonValue; + + public JsonValueDebugView(JsonValue jsonValue) + { + this.jsonValue = jsonValue; + } + + [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)] + public JsonObject ObjectView { + get { + if (this.jsonValue.IsJsonObject) + { + return (JsonObject)this.jsonValue.reference; + } + else + { + return null; + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)] + public JsonArray ArrayView { + get { + if (this.jsonValue.IsJsonArray) + { + return (JsonArray)this.jsonValue.reference; + } + else + { + return null; + } + } + } + + public JsonValueType Type { + get { + return this.jsonValue.Type; + } + } + + public object Value { + get { + if (this.jsonValue.IsJsonObject) + { + return (JsonObject)this.jsonValue.reference; + } + else if (this.jsonValue.IsJsonArray) + { + return (JsonArray)this.jsonValue.reference; + } + else + { + return this.jsonValue; + } + } + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/LightJson/JsonValueType.cs b/src/ICSharpCode.Decompiler/Metadata/LightJson/JsonValueType.cs new file mode 100644 index 0000000..9eb97ec --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/LightJson/JsonValueType.cs @@ -0,0 +1,41 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. + +namespace LightJson +{ + /// + /// Enumerates the types of Json values. + /// + internal enum JsonValueType : byte + { + /// + /// A null value. + /// + Null = 0, + + /// + /// A boolean value. + /// + Boolean, + + /// + /// A number value. + /// + Number, + + /// + /// A string value. + /// + String, + + /// + /// An object value. + /// + Object, + + /// + /// An array value. + /// + Array, + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/LightJson/Serialization/JsonParseException.cs b/src/ICSharpCode.Decompiler/Metadata/LightJson/Serialization/JsonParseException.cs new file mode 100644 index 0000000..28aa1c9 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/LightJson/Serialization/JsonParseException.cs @@ -0,0 +1,103 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. + +namespace LightJson.Serialization +{ + using System; + + /// + /// The exception that is thrown when a JSON message cannot be parsed. + /// + /// + /// This exception is only intended to be thrown by LightJson. + /// + internal sealed class JsonParseException : Exception + { + /// + /// Initializes a new instance of the class. + /// + public JsonParseException() + : base(GetDefaultMessage(ErrorType.Unknown)) + { + } + + /// + /// Initializes a new instance of the class with the given error type and position. + /// + /// The error type that describes the cause of the error. + /// The position in the text where the error occurred. + public JsonParseException(ErrorType type, TextPosition position) + : this(GetDefaultMessage(type), type, position) + { + } + + /// + /// Initializes a new instance of the class with the given message, error type, and position. + /// + /// The message that describes the error. + /// The error type that describes the cause of the error. + /// The position in the text where the error occurred. + public JsonParseException(string message, ErrorType type, TextPosition position) + : base(message) + { + this.Type = type; + this.Position = position; + } + + /// + /// Enumerates the types of errors that can occur when parsing a JSON message. + /// + public enum ErrorType : int + { + /// + /// Indicates that the cause of the error is unknown. + /// + Unknown = 0, + + /// + /// Indicates that the text ended before the message could be parsed. + /// + IncompleteMessage, + + /// + /// Indicates that a JsonObject contains more than one key with the same name. + /// + DuplicateObjectKeys, + + /// + /// Indicates that the parser encountered and invalid or unexpected character. + /// + InvalidOrUnexpectedCharacter, + } + + /// + /// Gets the text position where the error occurred. + /// + /// The text position where the error occurred. + public TextPosition Position { get; private set; } + + /// + /// Gets the type of error that caused the exception to be thrown. + /// + /// The type of error that caused the exception to be thrown. + public ErrorType Type { get; private set; } + + private static string GetDefaultMessage(ErrorType type) + { + switch (type) + { + case ErrorType.IncompleteMessage: + return "The string ended before a value could be parsed."; + + case ErrorType.InvalidOrUnexpectedCharacter: + return "The parser encountered an invalid or unexpected character."; + + case ErrorType.DuplicateObjectKeys: + return "The parser encountered a JsonObject with duplicate keys."; + + default: + return "An error occurred while parsing the JSON message."; + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/LightJson/Serialization/JsonReader.cs b/src/ICSharpCode.Decompiler/Metadata/LightJson/Serialization/JsonReader.cs new file mode 100644 index 0000000..65836fc --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/LightJson/Serialization/JsonReader.cs @@ -0,0 +1,463 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. + +namespace LightJson.Serialization +{ + using System; + using System.Globalization; + using System.IO; + using System.Text; + + using ErrorType = JsonParseException.ErrorType; + + /// + /// Represents a reader that can read JsonValues. + /// + internal sealed class JsonReader + { + private TextScanner scanner; + + private JsonReader(TextReader reader) + { + this.scanner = new TextScanner(reader); + } + + /// + /// Creates a JsonValue by using the given TextReader. + /// + /// The TextReader used to read a JSON message. + /// The parsed . + public static JsonValue Parse(TextReader reader) + { + if (reader == null) + { + throw new ArgumentNullException(nameof(reader)); + } + + return new JsonReader(reader).Parse(); + } + + /// + /// Creates a JsonValue by reader the JSON message in the given string. + /// + /// The string containing the JSON message. + /// The parsed . + public static JsonValue Parse(string source) + { + if (source == null) + { + throw new ArgumentNullException(nameof(source)); + } + + using (var reader = new StringReader(source)) + { + return Parse(reader); + } + } + + private string ReadJsonKey() + { + return this.ReadString(); + } + + private JsonValue ReadJsonValue() + { + this.scanner.SkipWhitespace(); + + var next = this.scanner.Peek(); + + if (char.IsNumber(next)) + { + return this.ReadNumber(); + } + + switch (next) + { + case '{': + return this.ReadObject(); + + case '[': + return this.ReadArray(); + + case '"': + return this.ReadString(); + + case '-': + return this.ReadNumber(); + + case 't': + case 'f': + return this.ReadBoolean(); + + case 'n': + return this.ReadNull(); + + default: + throw new JsonParseException( + ErrorType.InvalidOrUnexpectedCharacter, + this.scanner.Position); + } + } + + private JsonValue ReadNull() + { + this.scanner.Assert("null"); + return JsonValue.Null; + } + + private JsonValue ReadBoolean() + { + switch (this.scanner.Peek()) + { + case 't': + this.scanner.Assert("true"); + return true; + + default: + this.scanner.Assert("false"); + return false; + } + } + + private void ReadDigits(StringBuilder builder) + { + while (true) + { + var next = this.scanner.Peek(throwAtEndOfFile: false); + if (next == -1 || !char.IsNumber((char)next)) + { + return; + } + + builder.Append(this.scanner.Read()); + } + } + + private JsonValue ReadNumber() + { + var builder = new StringBuilder(); + + if (this.scanner.Peek() == '-') + { + builder.Append(this.scanner.Read()); + } + + if (this.scanner.Peek() == '0') + { + builder.Append(this.scanner.Read()); + } + else + { + this.ReadDigits(builder); + } + + if (this.scanner.Peek(throwAtEndOfFile: false) == '.') + { + builder.Append(this.scanner.Read()); + this.ReadDigits(builder); + } + + if (this.scanner.Peek(throwAtEndOfFile: false) == 'e' || this.scanner.Peek(throwAtEndOfFile: false) == 'E') + { + builder.Append(this.scanner.Read()); + + var next = this.scanner.Peek(); + + switch (next) + { + case '+': + case '-': + builder.Append(this.scanner.Read()); + break; + } + + this.ReadDigits(builder); + } + + return double.Parse( + builder.ToString(), + CultureInfo.InvariantCulture); + } + + private string ReadString() + { + var builder = new StringBuilder(); + + this.scanner.Assert('"'); + + while (true) + { + var errorPosition = this.scanner.Position; + var c = this.scanner.Read(); + + if (c == '\\') + { + errorPosition = this.scanner.Position; + c = this.scanner.Read(); + + switch (char.ToLower(c)) + { + case '"': + case '\\': + case '/': + builder.Append(c); + break; + case 'b': + builder.Append('\b'); + break; + case 'f': + builder.Append('\f'); + break; + case 'n': + builder.Append('\n'); + break; + case 'r': + builder.Append('\r'); + break; + case 't': + builder.Append('\t'); + break; + case 'u': + builder.Append(this.ReadUnicodeLiteral()); + break; + default: + throw new JsonParseException( + ErrorType.InvalidOrUnexpectedCharacter, + errorPosition); + } + } + else if (c == '"') + { + break; + } + else + { + if (char.IsControl(c)) + { + throw new JsonParseException( + ErrorType.InvalidOrUnexpectedCharacter, + errorPosition); + } + else + { + builder.Append(c); + } + } + } + + return builder.ToString(); + } + + private int ReadHexDigit() + { + var errorPosition = this.scanner.Position; + switch (char.ToUpper(this.scanner.Read())) + { + case '0': + return 0; + + case '1': + return 1; + + case '2': + return 2; + + case '3': + return 3; + + case '4': + return 4; + + case '5': + return 5; + + case '6': + return 6; + + case '7': + return 7; + + case '8': + return 8; + + case '9': + return 9; + + case 'A': + return 10; + + case 'B': + return 11; + + case 'C': + return 12; + + case 'D': + return 13; + + case 'E': + return 14; + + case 'F': + return 15; + + default: + throw new JsonParseException( + ErrorType.InvalidOrUnexpectedCharacter, + errorPosition); + } + } + + private char ReadUnicodeLiteral() + { + var value = 0; + + value += this.ReadHexDigit() * 4096; // 16^3 + value += this.ReadHexDigit() * 256; // 16^2 + value += this.ReadHexDigit() * 16; // 16^1 + value += this.ReadHexDigit(); // 16^0 + + return (char)value; + } + + private JsonObject ReadObject() + { + return this.ReadObject(new JsonObject()); + } + + private JsonObject ReadObject(JsonObject jsonObject) + { + this.scanner.Assert('{'); + + this.scanner.SkipWhitespace(); + + if (this.scanner.Peek() == '}') + { + this.scanner.Read(); + } + else + { + while (true) + { + this.scanner.SkipWhitespace(); + + var errorPosition = this.scanner.Position; + var key = this.ReadJsonKey(); + + if (jsonObject.ContainsKey(key)) + { + throw new JsonParseException( + ErrorType.DuplicateObjectKeys, + errorPosition); + } + + this.scanner.SkipWhitespace(); + + this.scanner.Assert(':'); + + this.scanner.SkipWhitespace(); + + var value = this.ReadJsonValue(); + + jsonObject.Add(key, value); + + this.scanner.SkipWhitespace(); + + errorPosition = this.scanner.Position; + var next = this.scanner.Read(); + if (next == ',') + { + // Allow trailing commas in objects + this.scanner.SkipWhitespace(); + if (this.scanner.Peek() == '}') + { + next = this.scanner.Read(); + } + } + + if (next == '}') + { + break; + } + else if (next == ',') + { + continue; + } + else + { + throw new JsonParseException( + ErrorType.InvalidOrUnexpectedCharacter, + errorPosition); + } + } + } + + return jsonObject; + } + + private JsonArray ReadArray() + { + return this.ReadArray(new JsonArray()); + } + + private JsonArray ReadArray(JsonArray jsonArray) + { + this.scanner.Assert('['); + + this.scanner.SkipWhitespace(); + + if (this.scanner.Peek() == ']') + { + this.scanner.Read(); + } + else + { + while (true) + { + this.scanner.SkipWhitespace(); + + var value = this.ReadJsonValue(); + + jsonArray.Add(value); + + this.scanner.SkipWhitespace(); + + var errorPosition = this.scanner.Position; + var next = this.scanner.Read(); + if (next == ',') + { + // Allow trailing commas in arrays + this.scanner.SkipWhitespace(); + if (this.scanner.Peek() == ']') + { + next = this.scanner.Read(); + } + } + + if (next == ']') + { + break; + } + else if (next == ',') + { + continue; + } + else + { + throw new JsonParseException( + ErrorType.InvalidOrUnexpectedCharacter, + errorPosition); + } + } + } + + return jsonArray; + } + + private JsonValue Parse() + { + this.scanner.SkipWhitespace(); + return this.ReadJsonValue(); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/LightJson/Serialization/TextPosition.cs b/src/ICSharpCode.Decompiler/Metadata/LightJson/Serialization/TextPosition.cs new file mode 100644 index 0000000..ad960e8 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/LightJson/Serialization/TextPosition.cs @@ -0,0 +1,21 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. + +namespace LightJson.Serialization +{ + /// + /// Represents a position within a plain text resource. + /// + internal struct TextPosition + { + /// + /// The column position, 0-based. + /// + public long Column; + + /// + /// The line position, 0-based. + /// + public long Line; + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/LightJson/Serialization/TextScanner.cs b/src/ICSharpCode.Decompiler/Metadata/LightJson/Serialization/TextScanner.cs new file mode 100644 index 0000000..75513e0 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/LightJson/Serialization/TextScanner.cs @@ -0,0 +1,238 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. + +namespace LightJson.Serialization +{ + using System.IO; + + using ErrorType = JsonParseException.ErrorType; + + /// + /// Represents a text scanner that reads one character at a time. + /// + internal sealed class TextScanner + { + private TextReader reader; + private TextPosition position; + + /// + /// Initializes a new instance of the class. + /// + /// The TextReader to read the text. + public TextScanner(TextReader reader) + { + this.reader = reader; + } + + /// + /// Gets the position of the scanner within the text. + /// + /// The position of the scanner within the text. + public TextPosition Position { + get { + return this.position; + } + } + + /// + /// Reads the next character in the stream without changing the current position. + /// + /// The next character in the stream. + public char Peek() + => (char)this.Peek(throwAtEndOfFile: true); + + /// + /// Reads the next character in the stream without changing the current position. + /// + /// to throw an exception if the end of the file is + /// reached; otherwise, . + /// The next character in the stream, or -1 if the end of the file is reached with + /// set to . + public int Peek(bool throwAtEndOfFile) + { + var next = this.reader.Peek(); + + if (next == -1 && throwAtEndOfFile) + { + throw new JsonParseException( + ErrorType.IncompleteMessage, + this.position); + } + else + { + return next; + } + } + + /// + /// Reads the next character in the stream, advancing the text position. + /// + /// The next character in the stream. + public char Read() + { + var next = this.reader.Read(); + + if (next == -1) + { + throw new JsonParseException( + ErrorType.IncompleteMessage, + this.position); + } + else + { + if (next == '\n') + { + this.position.Line += 1; + this.position.Column = 0; + } + else + { + this.position.Column += 1; + } + + return (char)next; + } + } + + /// + /// Advances the scanner to next non-whitespace character. + /// + public void SkipWhitespace() + { + while (true) + { + var next = this.Peek(); + if (char.IsWhiteSpace(next)) + { + this.Read(); + continue; + } + else if (next == '/') + { + this.SkipComment(); + continue; + } + else + { + break; + } + } + } + + /// + /// Verifies that the given character matches the next character in the stream. + /// If the characters do not match, an exception will be thrown. + /// + /// The expected character. + public void Assert(char next) + { + var errorPosition = this.position; + if (this.Read() != next) + { + throw new JsonParseException( + string.Format("Parser expected '{0}'", next), + ErrorType.InvalidOrUnexpectedCharacter, + errorPosition); + } + } + + /// + /// Verifies that the given string matches the next characters in the stream. + /// If the strings do not match, an exception will be thrown. + /// + /// The expected string. + public void Assert(string next) + { + for (var i = 0; i < next.Length; i += 1) + { + this.Assert(next[i]); + } + } + + private void SkipComment() + { + // First character is the first slash + this.Read(); + switch (this.Peek()) + { + case '/': + this.SkipLineComment(); + return; + + case '*': + this.SkipBlockComment(); + return; + + default: + throw new JsonParseException( + string.Format("Parser expected '{0}'", this.Peek()), + ErrorType.InvalidOrUnexpectedCharacter, + this.position); + } + } + + private void SkipLineComment() + { + // First character is the second '/' of the opening '//' + this.Read(); + + while (true) + { + switch (this.reader.Peek()) + { + case '\n': + // Reached the end of the line + this.Read(); + return; + + case -1: + // Reached the end of the file + return; + + default: + this.Read(); + continue; + } + } + } + + private void SkipBlockComment() + { + // First character is the '*' of the opening '/*' + this.Read(); + + var foundStar = false; + while (true) + { + switch (this.reader.Peek()) + { + case '*': + this.Read(); + foundStar = true; + continue; + + case '/': + this.Read(); + if (foundStar) + { + return; + } + else + { + foundStar = false; + continue; + } + + case -1: + // Reached the end of the file + return; + + default: + this.Read(); + foundStar = false; + continue; + } + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/MetadataExtensions.cs b/src/ICSharpCode.Decompiler/Metadata/MetadataExtensions.cs new file mode 100644 index 0000000..d696f35 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/MetadataExtensions.cs @@ -0,0 +1,406 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Security.Cryptography; +using System.Text; + +using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.TypeSystem.Implementation; +using ICSharpCode.Decompiler.Util; + +using SRM = System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler.Metadata +{ + public static class MetadataExtensions + { + static HashAlgorithm GetHashAlgorithm(this MetadataReader reader) + { + switch (reader.GetAssemblyDefinition().HashAlgorithm) + { + case AssemblyHashAlgorithm.None: + // only for multi-module assemblies? + return SHA1.Create(); + case AssemblyHashAlgorithm.MD5: + return MD5.Create(); + case AssemblyHashAlgorithm.Sha1: + return SHA1.Create(); + case AssemblyHashAlgorithm.Sha256: + return SHA256.Create(); + case AssemblyHashAlgorithm.Sha384: + return SHA384.Create(); + case AssemblyHashAlgorithm.Sha512: + return SHA512.Create(); + default: + return SHA1.Create(); // default? + } + } + + static string CalculatePublicKeyToken(BlobHandle blob, MetadataReader reader) + { + // Calculate public key token: + // 1. hash the public key using the appropriate algorithm. + var publicKeyTokenBytes = reader.GetHashAlgorithm().ComputeHash(reader.GetBlobBytes(blob)); + // 2. take the last 8 bytes + // 3. according to Cecil we need to reverse them, other sources did not mention this. + return publicKeyTokenBytes.TakeLast(8).Reverse().ToHexString(8); + } + + public static string GetPublicKeyToken(this MetadataReader reader) + { + if (!reader.IsAssembly) + return string.Empty; + var asm = reader.GetAssemblyDefinition(); + var publicKey = "null"; + if (!asm.PublicKey.IsNil) + { + // AssemblyFlags.PublicKey does not apply to assembly definitions + publicKey = CalculatePublicKeyToken(asm.PublicKey, reader); + } + return publicKey; + } + + public static string GetFullAssemblyName(this MetadataReader reader) + { + if (!reader.IsAssembly) + return string.Empty; + var asm = reader.GetAssemblyDefinition(); + var publicKey = reader.GetPublicKeyToken(); + return $"{reader.GetString(asm.Name)}, " + + $"Version={asm.Version}, " + + $"Culture={(asm.Culture.IsNil ? "neutral" : reader.GetString(asm.Culture))}, " + + $"PublicKeyToken={publicKey}"; + } + + public static bool TryGetFullAssemblyName(this MetadataReader reader, out string assemblyName) + { + try + { + assemblyName = GetFullAssemblyName(reader); + return true; + } + catch (BadImageFormatException) + { + assemblyName = null; + return false; + } + } + + public static string GetFullAssemblyName(this SRM.AssemblyReference reference, MetadataReader reader) + { + var publicKey = "null"; + if (!reference.PublicKeyOrToken.IsNil) + { + if ((reference.Flags & AssemblyFlags.PublicKey) != 0) + { + publicKey = CalculatePublicKeyToken(reference.PublicKeyOrToken, reader); + } + else + { + publicKey = reader.GetBlobBytes(reference.PublicKeyOrToken).ToHexString(8); + } + } + var properties = ""; + if ((reference.Flags & AssemblyFlags.Retargetable) != 0) + properties = ", Retargetable=true"; + return $"{reader.GetString(reference.Name)}, " + + $"Version={reference.Version}, " + + $"Culture={(reference.Culture.IsNil ? "neutral" : reader.GetString(reference.Culture))}, " + + $"PublicKeyToken={publicKey}{properties}"; + } + + public static bool TryGetFullAssemblyName(this SRM.AssemblyReference reference, MetadataReader reader, out string assemblyName) + { + try + { + assemblyName = GetFullAssemblyName(reference, reader); + return true; + } + catch (BadImageFormatException) + { + assemblyName = null; + return false; + } + } + + public static string ToHexString(this IEnumerable bytes, int estimatedLength) + { + if (bytes == null) + throw new ArgumentNullException(nameof(bytes)); + + var sb = new StringBuilder(estimatedLength * 2); + foreach (var b in bytes) + sb.AppendFormat("{0:x2}", b); + return sb.ToString(); + } + + public static string ToHexString(this BlobReader reader) + { + var sb = new StringBuilder(reader.Length * 3); + for (var i = 0; i < reader.Length; i++) + { + if (i == 0) + sb.AppendFormat("{0:X2}", reader.ReadByte()); + else + sb.AppendFormat("-{0:X2}", reader.ReadByte()); + } + return sb.ToString(); + } + + public static IEnumerable GetTopLevelTypeDefinitions(this MetadataReader reader) + { + foreach (var handle in reader.TypeDefinitions) + { + var td = reader.GetTypeDefinition(handle); + if (td.GetDeclaringType().IsNil) + yield return handle; + } + } + + public static string ToILNameString(this FullTypeName typeName, bool omitGenerics = false) + { + string name; + if (typeName.IsNested) + { + name = typeName.Name; + if (!omitGenerics) + { + var localTypeParameterCount = typeName.GetNestedTypeAdditionalTypeParameterCount(typeName.NestingLevel - 1); + if (localTypeParameterCount > 0) + name += "`" + localTypeParameterCount; + } + name = Disassembler.DisassemblerHelpers.Escape(name); + return $"{typeName.GetDeclaringType().ToILNameString(omitGenerics)}/{name}"; + } + if (!string.IsNullOrEmpty(typeName.TopLevelTypeName.Namespace)) + { + name = $"{typeName.TopLevelTypeName.Namespace}.{typeName.Name}"; + if (!omitGenerics && typeName.TypeParameterCount > 0) + name += "`" + typeName.TypeParameterCount; + } + else + { + name = typeName.Name; + if (!omitGenerics && typeName.TypeParameterCount > 0) + name += "`" + typeName.TypeParameterCount; + } + return Disassembler.DisassemblerHelpers.Escape(name); + } + + [Obsolete("Use MetadataModule.GetDeclaringModule() instead")] + public static IModuleReference GetDeclaringModule(this TypeReferenceHandle handle, MetadataReader reader) + { + var tr = reader.GetTypeReference(handle); + switch (tr.ResolutionScope.Kind) + { + case HandleKind.TypeReference: + return ((TypeReferenceHandle)tr.ResolutionScope).GetDeclaringModule(reader); + case HandleKind.AssemblyReference: + var asmRef = reader.GetAssemblyReference((AssemblyReferenceHandle)tr.ResolutionScope); + return new DefaultAssemblyReference(reader.GetString(asmRef.Name)); + case HandleKind.ModuleReference: + var modRef = reader.GetModuleReference((ModuleReferenceHandle)tr.ResolutionScope); + return new DefaultAssemblyReference(reader.GetString(modRef.Name)); + default: + return DefaultAssemblyReference.CurrentAssembly; + } + } + + internal static readonly TypeProvider minimalCorlibTypeProvider = + new TypeProvider(new SimpleCompilation(MinimalCorlib.Instance)); + + /// + /// An attribute type provider that can be used to decode attribute signatures + /// that only mention built-in types. + /// + public static ICustomAttributeTypeProvider MinimalAttributeTypeProvider { + get => minimalCorlibTypeProvider; + } + + public static ISignatureTypeProvider MinimalSignatureTypeProvider { + get => minimalCorlibTypeProvider; + } + + public static PrimitiveTypeCode ToPrimitiveTypeCode(this KnownTypeCode typeCode) + { + switch (typeCode) + { + case KnownTypeCode.Object: + return PrimitiveTypeCode.Object; + case KnownTypeCode.Boolean: + return PrimitiveTypeCode.Boolean; + case KnownTypeCode.Char: + return PrimitiveTypeCode.Char; + case KnownTypeCode.SByte: + return PrimitiveTypeCode.SByte; + case KnownTypeCode.Byte: + return PrimitiveTypeCode.Byte; + case KnownTypeCode.Int16: + return PrimitiveTypeCode.Int16; + case KnownTypeCode.UInt16: + return PrimitiveTypeCode.UInt16; + case KnownTypeCode.Int32: + return PrimitiveTypeCode.Int32; + case KnownTypeCode.UInt32: + return PrimitiveTypeCode.UInt32; + case KnownTypeCode.Int64: + return PrimitiveTypeCode.Int64; + case KnownTypeCode.UInt64: + return PrimitiveTypeCode.UInt64; + case KnownTypeCode.Single: + return PrimitiveTypeCode.Single; + case KnownTypeCode.Double: + return PrimitiveTypeCode.Double; + case KnownTypeCode.String: + return PrimitiveTypeCode.String; + case KnownTypeCode.Void: + return PrimitiveTypeCode.Void; + case KnownTypeCode.TypedReference: + return PrimitiveTypeCode.TypedReference; + case KnownTypeCode.IntPtr: + return PrimitiveTypeCode.IntPtr; + case KnownTypeCode.UIntPtr: + return PrimitiveTypeCode.UIntPtr; + default: + throw new ArgumentOutOfRangeException(); + } + } + + public static KnownTypeCode ToKnownTypeCode(this PrimitiveTypeCode typeCode) + { + switch (typeCode) + { + case PrimitiveTypeCode.Boolean: + return KnownTypeCode.Boolean; + case PrimitiveTypeCode.Byte: + return KnownTypeCode.Byte; + case PrimitiveTypeCode.SByte: + return KnownTypeCode.SByte; + case PrimitiveTypeCode.Char: + return KnownTypeCode.Char; + case PrimitiveTypeCode.Int16: + return KnownTypeCode.Int16; + case PrimitiveTypeCode.UInt16: + return KnownTypeCode.UInt16; + case PrimitiveTypeCode.Int32: + return KnownTypeCode.Int32; + case PrimitiveTypeCode.UInt32: + return KnownTypeCode.UInt32; + case PrimitiveTypeCode.Int64: + return KnownTypeCode.Int64; + case PrimitiveTypeCode.UInt64: + return KnownTypeCode.UInt64; + case PrimitiveTypeCode.Single: + return KnownTypeCode.Single; + case PrimitiveTypeCode.Double: + return KnownTypeCode.Double; + case PrimitiveTypeCode.IntPtr: + return KnownTypeCode.IntPtr; + case PrimitiveTypeCode.UIntPtr: + return KnownTypeCode.UIntPtr; + case PrimitiveTypeCode.Object: + return KnownTypeCode.Object; + case PrimitiveTypeCode.String: + return KnownTypeCode.String; + case PrimitiveTypeCode.TypedReference: + return KnownTypeCode.TypedReference; + case PrimitiveTypeCode.Void: + return KnownTypeCode.Void; + default: + return KnownTypeCode.None; + } + } + + public static IEnumerable GetModuleReferences(this MetadataReader metadata) + { + var rowCount = metadata.GetTableRowCount(TableIndex.ModuleRef); + for (var row = 1; row <= rowCount; row++) + { + yield return MetadataTokens.ModuleReferenceHandle(row); + } + } + + public static IEnumerable GetTypeSpecifications(this MetadataReader metadata) + { + var rowCount = metadata.GetTableRowCount(TableIndex.TypeSpec); + for (var row = 1; row <= rowCount; row++) + { + yield return MetadataTokens.TypeSpecificationHandle(row); + } + } + + public static IEnumerable GetMethodSpecifications(this MetadataReader metadata) + { + var rowCount = metadata.GetTableRowCount(TableIndex.MethodSpec); + for (var row = 1; row <= rowCount; row++) + { + yield return MetadataTokens.MethodSpecificationHandle(row); + } + } + + public static IEnumerable<(Handle Handle, MethodSemanticsAttributes Semantics, MethodDefinitionHandle Method, EntityHandle Association)> GetMethodSemantics(this MetadataReader metadata) + { + var offset = metadata.GetTableMetadataOffset(TableIndex.MethodSemantics); + var rowSize = metadata.GetTableRowSize(TableIndex.MethodSemantics); + var rowCount = metadata.GetTableRowCount(TableIndex.MethodSemantics); + + var methodSmall = metadata.GetTableRowCount(TableIndex.MethodDef) <= ushort.MaxValue; + var assocSmall = metadata.GetTableRowCount(TableIndex.Property) <= ushort.MaxValue && metadata.GetTableRowCount(TableIndex.Event) <= ushort.MaxValue; + var assocOffset = (methodSmall ? 2 : 4) + 2; + for (var row = 0; row < rowCount; row++) + { + yield return Read(row); + } + + unsafe (Handle Handle, MethodSemanticsAttributes Semantics, MethodDefinitionHandle Method, EntityHandle Association) Read(int row) + { + var ptr = metadata.MetadataPointer + offset + rowSize * row; + var methodDef = methodSmall ? *(ushort*)(ptr + 2) : (int)*(uint*)(ptr + 2); + var assocDef = assocSmall ? *(ushort*)(ptr + assocOffset) : (int)*(uint*)(ptr + assocOffset); + EntityHandle propOrEvent; + if ((assocDef & 0x1) == 1) + { + propOrEvent = MetadataTokens.PropertyDefinitionHandle(assocDef >> 1); + } + else + { + propOrEvent = MetadataTokens.EventDefinitionHandle(assocDef >> 1); + } + return (MetadataTokens.Handle(0x18000000 | (row + 1)), (MethodSemanticsAttributes)(*(ushort*)ptr), MetadataTokens.MethodDefinitionHandle(methodDef), propOrEvent); + } + } + + public static IEnumerable GetFieldLayouts(this MetadataReader metadata) + { + var rowCount = metadata.GetTableRowCount(TableIndex.FieldLayout); + for (var row = 1; row <= rowCount; row++) + { + yield return MetadataTokens.EntityHandle(TableIndex.FieldLayout, row); + } + } + + public unsafe static (int Offset, FieldDefinitionHandle FieldDef) GetFieldLayout(this MetadataReader metadata, EntityHandle fieldLayoutHandle) + { + var startPointer = metadata.MetadataPointer; + var offset = metadata.GetTableMetadataOffset(TableIndex.FieldLayout); + var rowSize = metadata.GetTableRowSize(TableIndex.FieldLayout); + var rowCount = metadata.GetTableRowCount(TableIndex.FieldLayout); + + var fieldRowNo = metadata.GetRowNumber(fieldLayoutHandle); + var small = metadata.GetTableRowCount(TableIndex.Field) <= ushort.MaxValue; + for (var row = rowCount - 1; row >= 0; row--) + { + var ptr = startPointer + offset + rowSize * row; + var rowNo = small ? *(ushort*)(ptr + 4) : *(uint*)(ptr + 4); + if (fieldRowNo == rowNo) + { + return (*(int*)ptr, MetadataTokens.FieldDefinitionHandle(fieldRowNo)); + } + } + return (0, default); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/MetadataTokenHelpers.cs b/src/ICSharpCode.Decompiler/Metadata/MetadataTokenHelpers.cs new file mode 100644 index 0000000..6aa6bbf --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/MetadataTokenHelpers.cs @@ -0,0 +1,59 @@ +// Copyright (c) 2018 Siegfried Pammer +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; + +namespace ICSharpCode.Decompiler.Metadata +{ + public static class MetadataTokenHelpers + { + public static EntityHandle? TryAsEntityHandle(int metadataToken) + { + // SRM would interpret negative token values as virtual tokens, + // but that causes problems later on. + if (metadataToken < 0) + return null; + try + { + return MetadataTokens.EntityHandle(metadataToken); + } + catch (ArgumentException) + { + return null; + } + } + + public static EntityHandle EntityHandleOrNil(int metadataToken) + { + // SRM would interpret negative token values as virtual tokens, + // but that causes problems later on. + if (metadataToken < 0) + return MetadataTokens.EntityHandle(0); + try + { + return MetadataTokens.EntityHandle(metadataToken); + } + catch (ArgumentException) + { + return MetadataTokens.EntityHandle(0); + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/MethodSemanticsLookup.cs b/src/ICSharpCode.Decompiler/Metadata/MethodSemanticsLookup.cs new file mode 100644 index 0000000..4a0af54 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/MethodSemanticsLookup.cs @@ -0,0 +1,104 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; + +namespace ICSharpCode.Decompiler.Metadata +{ + /// + /// Lookup structure that, for an accessor, can find the associated property/event. + /// + class MethodSemanticsLookup + { + const MethodSemanticsAttributes csharpAccessors = + MethodSemanticsAttributes.Getter | MethodSemanticsAttributes.Setter + | MethodSemanticsAttributes.Adder | MethodSemanticsAttributes.Remover; + + readonly struct Entry : IComparable + { + public readonly MethodSemanticsAttributes Semantics; + public readonly int MethodRowNumber; + public MethodDefinitionHandle Method => MetadataTokens.MethodDefinitionHandle(MethodRowNumber); + public readonly EntityHandle Association; + + public Entry(MethodSemanticsAttributes semantics, MethodDefinitionHandle method, EntityHandle association) + { + Semantics = semantics; + MethodRowNumber = MetadataTokens.GetRowNumber(method); + Association = association; + } + + public int CompareTo(Entry other) + { + return MethodRowNumber.CompareTo(other.MethodRowNumber); + } + } + + // entries, sorted by MethodRowNumber + readonly List entries; + + public MethodSemanticsLookup(MetadataReader metadata, MethodSemanticsAttributes filter = csharpAccessors) + { + if ((filter & MethodSemanticsAttributes.Other) != 0) + { + throw new NotSupportedException("SRM doesn't provide access to 'other' accessors"); + } + entries = new List(metadata.GetTableRowCount(TableIndex.MethodSemantics)); + foreach (var propHandle in metadata.PropertyDefinitions) + { + var prop = metadata.GetPropertyDefinition(propHandle); + var accessors = prop.GetAccessors(); + AddEntry(MethodSemanticsAttributes.Getter, accessors.Getter, propHandle); + AddEntry(MethodSemanticsAttributes.Setter, accessors.Setter, propHandle); + } + foreach (var eventHandle in metadata.EventDefinitions) + { + var ev = metadata.GetEventDefinition(eventHandle); + var accessors = ev.GetAccessors(); + AddEntry(MethodSemanticsAttributes.Adder, accessors.Adder, eventHandle); + AddEntry(MethodSemanticsAttributes.Remover, accessors.Remover, eventHandle); + AddEntry(MethodSemanticsAttributes.Raiser, accessors.Raiser, eventHandle); + } + entries.Sort(); + + void AddEntry(MethodSemanticsAttributes semantics, MethodDefinitionHandle method, EntityHandle association) + { + if ((semantics & filter) == 0 || method.IsNil) + return; + entries.Add(new Entry(semantics, method, association)); + } + } + + public (EntityHandle, MethodSemanticsAttributes) GetSemantics(MethodDefinitionHandle method) + { + var pos = entries.BinarySearch(new Entry(0, method, default(EntityHandle))); + if (pos >= 0) + { + return (entries[pos].Association, entries[pos].Semantics); + } + else + { + return (default(EntityHandle), 0); + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/OperandType.cs b/src/ICSharpCode.Decompiler/Metadata/OperandType.cs new file mode 100644 index 0000000..8353504 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/OperandType.cs @@ -0,0 +1,117 @@ +// Copyright (c) 2014 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler.Metadata +{ + public enum OperandType + { + BrTarget, + Field, + I, + I8, + Method, + None, + R = 7, + Sig = 9, + String, + Switch, + Tok, + Type, + Variable, + ShortBrTarget, + ShortI, + ShortR, + ShortVariable + } + + public static partial class ILOpCodeExtensions + { + public static OperandType GetOperandType(this ILOpCode opCode) + { + var index = (ushort)((((int)opCode & 0x200) >> 1) | ((int)opCode & 0xff)); + if (index >= operandTypes.Length) + return (OperandType)255; + return (OperandType)operandTypes[index]; + } + + public static string GetDisplayName(this ILOpCode opCode) + { + var index = (ushort)((((int)opCode & 0x200) >> 1) | ((int)opCode & 0xff)); + if (index >= operandNames.Length) + return ""; + return operandNames[index]; + } + + public static bool IsDefined(this ILOpCode opCode) + { + return !string.IsNullOrEmpty(GetDisplayName(opCode)); + } + + static ILOpCodeExtensions() + { + ILKeywords = BuildKeywordList( + "abstract", "algorithm", "alignment", "ansi", "any", "arglist", + "array", "as", "assembly", "assert", "at", "auto", "autochar", "beforefieldinit", + "blob", "blob_object", "bool", "brnull", "brnull.s", "brzero", "brzero.s", "bstr", + "bytearray", "byvalstr", "callmostderived", "carray", "catch", "cdecl", "cf", + "char", "cil", "class", "clsid", "const", "currency", "custom", "date", "decimal", + "default", "demand", "deny", "endmac", "enum", "error", "explicit", "extends", "extern", + "false", "famandassem", "family", "famorassem", "fastcall", "fault", "field", "filetime", + "filter", "final", "finally", "fixed", "float", "float32", "float64", "forwardref", + "fromunmanaged", "handler", "hidebysig", "hresult", "idispatch", "il", "illegal", + "implements", "implicitcom", "implicitres", "import", "in", "inheritcheck", "init", + "initonly", "instance", "int", "int16", "int32", "int64", "int8", "interface", "internalcall", + "iunknown", "lasterr", "lcid", "linkcheck", "literal", "localloc", "lpstr", "lpstruct", "lptstr", + "lpvoid", "lpwstr", "managed", "marshal", "method", "modopt", "modreq", "native", "nested", + "newslot", "noappdomain", "noinlining", "nomachine", "nomangle", "nometadata", "noncasdemand", + "noncasinheritance", "noncaslinkdemand", "noprocess", "not", "not_in_gc_heap", "notremotable", + "notserialized", "null", "nullref", "object", "objectref", "opt", "optil", "out", + "permitonly", "pinned", "pinvokeimpl", "prefix1", "prefix2", "prefix3", "prefix4", "prefix5", "prefix6", + "prefix7", "prefixref", "prejitdeny", "prejitgrant", "preservesig", "private", "privatescope", "protected", + "public", "record", "refany", "reqmin", "reqopt", "reqrefuse", "reqsecobj", "request", "retval", + "rtspecialname", "runtime", "safearray", "sealed", "sequential", "serializable", "special", "specialname", + "static", "stdcall", "storage", "stored_object", "stream", "streamed_object", "string", "struct", + "synchronized", "syschar", "sysstring", "tbstr", "thiscall", "tls", "to", "true", "typedref", + "unicode", "unmanaged", "unmanagedexp", "unsigned", "unused", "userdefined", "value", "valuetype", + "vararg", "variant", "vector", "virtual", "void", "wchar", "winapi", "with", "wrapper", + + // These are not listed as keywords in spec, but ILAsm treats them as such + "property", "type", "flags", "callconv", "strict", + // ILDasm uses these keywords for unsigned integers + "uint8", "uint16", "uint32", "uint64" + ); + } + + public static readonly HashSet ILKeywords; + + static HashSet BuildKeywordList(params string[] keywords) + { + var s = new HashSet(keywords); + foreach (var inst in operandNames) + { + if (string.IsNullOrEmpty(inst)) + continue; + s.Add(inst); + } + return s; + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/PEFile.cs b/src/ICSharpCode.Decompiler/Metadata/PEFile.cs new file mode 100644 index 0000000..1260c11 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/PEFile.cs @@ -0,0 +1,196 @@ +// Copyright (c) 2018 Siegfried Pammer +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Reflection.Metadata; +using System.Reflection.PortableExecutable; + +using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.Metadata +{ + /// + /// PEFile is the main class the decompiler uses to represent a metadata assembly/module. + /// Every file on disk can be loaded into a standalone PEFile instance. + /// + /// A PEFile can be combined with its referenced assemblies/modules to form a type system, + /// in that case the class is used instead. + /// + /// + /// In addition to wrapping a System.Reflection.Metadata.PEReader, this class + /// contains a few decompiler-specific caches to allow efficiently constructing a type + /// system from multiple PEFiles. This allows the caches to be shared across multiple + /// decompiled type systems. + /// + [DebuggerDisplay("{FileName}")] + public class PEFile : IDisposable, TypeSystem.IModuleReference + { + public string FileName { get; } + public PEReader Reader { get; } + public MetadataReader Metadata { get; } + + public PEFile(string fileName, PEStreamOptions streamOptions = PEStreamOptions.Default, MetadataReaderOptions metadataOptions = MetadataReaderOptions.Default) + : this(fileName, new PEReader(new FileStream(fileName, FileMode.Open, FileAccess.Read), streamOptions), metadataOptions) + { + } + + public PEFile(string fileName, Stream stream, PEStreamOptions streamOptions = PEStreamOptions.Default, MetadataReaderOptions metadataOptions = MetadataReaderOptions.Default) + : this(fileName, new PEReader(stream, streamOptions), metadataOptions) + { + } + + public PEFile(string fileName, PEReader reader, MetadataReaderOptions metadataOptions = MetadataReaderOptions.Default) + { + this.FileName = fileName ?? throw new ArgumentNullException(nameof(fileName)); + this.Reader = reader ?? throw new ArgumentNullException(nameof(reader)); + if (!reader.HasMetadata) + throw new PEFileNotSupportedException("PE file does not contain any managed metadata."); + this.Metadata = reader.GetMetadataReader(metadataOptions); + } + + public bool IsAssembly => Metadata.IsAssembly; + public string Name => GetName(); + public string FullName => IsAssembly ? Metadata.GetFullAssemblyName() : Name; + + public TargetRuntime GetRuntime() + { + var version = Metadata.MetadataVersion; + if (version == null || version.Length <= 1) + return TargetRuntime.Unknown; + switch (version[1]) + { + case '1': + if (version.Length <= 3) + return TargetRuntime.Unknown; + if (version[3] == 1) + return TargetRuntime.Net_1_0; + else + return TargetRuntime.Net_1_1; + case '2': + return TargetRuntime.Net_2_0; + case '4': + return TargetRuntime.Net_4_0; + default: + return TargetRuntime.Unknown; + } + } + + string GetName() + { + var metadata = Metadata; + if (metadata.IsAssembly) + return metadata.GetString(metadata.GetAssemblyDefinition().Name); + return metadata.GetString(metadata.GetModuleDefinition().Name); + } + + public ImmutableArray AssemblyReferences => Metadata.AssemblyReferences.Select(r => new AssemblyReference(this, r)).ToImmutableArray(); + public ImmutableArray Resources => GetResources().ToImmutableArray(); + + IEnumerable GetResources() + { + var metadata = Metadata; + foreach (var h in metadata.ManifestResources) + { + yield return new MetadataResource(this, h); + } + } + + public void Dispose() + { + Reader.Dispose(); + } + + Dictionary typeLookup; + + /// + /// Finds the top-level-type with the specified name. + /// + public TypeDefinitionHandle GetTypeDefinition(TopLevelTypeName typeName) + { + var lookup = LazyInit.VolatileRead(ref typeLookup); + if (lookup == null) + { + lookup = new Dictionary(); + foreach (var handle in Metadata.TypeDefinitions) + { + var td = Metadata.GetTypeDefinition(handle); + if (!td.GetDeclaringType().IsNil) + { + continue; // nested type + } + var nsHandle = td.Namespace; + var ns = nsHandle.IsNil ? string.Empty : Metadata.GetString(nsHandle); + var name = ReflectionHelper.SplitTypeParameterCountFromReflectionName(Metadata.GetString(td.Name), out var typeParameterCount); + lookup[new TopLevelTypeName(ns, name, typeParameterCount)] = handle; + } + lookup = LazyInit.GetOrSet(ref typeLookup, lookup); + } + if (lookup.TryGetValue(typeName, out var resultHandle)) + return resultHandle; + else + return default; + } + + Dictionary typeForwarderLookup; + + /// + /// Finds the type forwarder with the specified name. + /// + public ExportedTypeHandle GetTypeForwarder(FullTypeName typeName) + { + var lookup = LazyInit.VolatileRead(ref typeForwarderLookup); + if (lookup == null) + { + lookup = new Dictionary(); + foreach (var handle in Metadata.ExportedTypes) + { + var td = Metadata.GetExportedType(handle); + lookup[td.GetFullTypeName(Metadata)] = handle; + } + lookup = LazyInit.GetOrSet(ref typeForwarderLookup, lookup); + } + if (lookup.TryGetValue(typeName, out var resultHandle)) + return resultHandle; + else + return default; + } + + MethodSemanticsLookup methodSemanticsLookup; + + internal MethodSemanticsLookup MethodSemanticsLookup { + get { + var r = LazyInit.VolatileRead(ref methodSemanticsLookup); + if (r != null) + return r; + else + return LazyInit.GetOrSet(ref methodSemanticsLookup, new MethodSemanticsLookup(Metadata)); + } + } + + IModule TypeSystem.IModuleReference.Resolve(ITypeResolveContext context) + { + return new MetadataModule(context.Compilation, this); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/SignatureBlobComparer.cs b/src/ICSharpCode.Decompiler/Metadata/SignatureBlobComparer.cs new file mode 100644 index 0000000..f2c57f1 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/SignatureBlobComparer.cs @@ -0,0 +1,206 @@ +// Copyright (c) 2018 Siegfried Pammer +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler.Metadata +{ + public static class SignatureBlobComparer + { + public static bool EqualsMethodSignature(BlobReader a, BlobReader b, MetadataReader contextForA, MetadataReader contextForB) + { + return EqualsMethodSignature(ref a, ref b, contextForA, contextForB); + } + + static bool EqualsMethodSignature(ref BlobReader a, ref BlobReader b, MetadataReader contextForA, MetadataReader contextForB) + { + SignatureHeader header; + // compare signature headers + if (a.RemainingBytes == 0 || b.RemainingBytes == 0 || (header = a.ReadSignatureHeader()) != b.ReadSignatureHeader()) + return false; + if (header.IsGeneric) + { + // read & compare generic parameter count + if (!IsSameCompressedInteger(ref a, ref b, out _)) + return false; + } + // read & compare parameter count + if (!IsSameCompressedInteger(ref a, ref b, out var totalParameterCount)) + return false; + if (!IsSameCompressedInteger(ref a, ref b, out var typeCode)) + return false; + if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) + return false; + var i = 0; + for (; i < totalParameterCount; i++) + { + if (!IsSameCompressedInteger(ref a, ref b, out typeCode)) + return false; + // varargs sentinel + if (typeCode == 65) + break; + if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) + return false; + } + for (; i < totalParameterCount; i++) + { + if (!IsSameCompressedInteger(ref a, ref b, out typeCode)) + return false; + if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) + return false; + } + return true; + } + + public static bool EqualsTypeSignature(BlobReader a, BlobReader b, MetadataReader contextForA, MetadataReader contextForB) + { + return EqualsTypeSignature(ref a, ref b, contextForA, contextForB); + } + + static bool EqualsTypeSignature(ref BlobReader a, ref BlobReader b, MetadataReader contextForA, MetadataReader contextForB) + { + if (!IsSameCompressedInteger(ref a, ref b, out var typeCode)) + return false; + return TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode); + } + + static bool IsSameCompressedInteger(ref BlobReader a, ref BlobReader b, out int value) + { + return a.TryReadCompressedInteger(out value) && b.TryReadCompressedInteger(out var otherValue) && value == otherValue; + } + + static bool IsSameCompressedSignedInteger(ref BlobReader a, ref BlobReader b, out int value) + { + return a.TryReadCompressedSignedInteger(out value) && b.TryReadCompressedSignedInteger(out var otherValue) && value == otherValue; + } + + static bool TypesAreEqual(ref BlobReader a, ref BlobReader b, MetadataReader contextForA, MetadataReader contextForB, int typeCode) + { + switch (typeCode) + { + case 0x1: // ELEMENT_TYPE_VOID + case 0x2: // ELEMENT_TYPE_BOOLEAN + case 0x3: // ELEMENT_TYPE_CHAR + case 0x4: // ELEMENT_TYPE_I1 + case 0x5: // ELEMENT_TYPE_U1 + case 0x6: // ELEMENT_TYPE_I2 + case 0x7: // ELEMENT_TYPE_U2 + case 0x8: // ELEMENT_TYPE_I4 + case 0x9: // ELEMENT_TYPE_U4 + case 0xA: // ELEMENT_TYPE_I8 + case 0xB: // ELEMENT_TYPE_U8 + case 0xC: // ELEMENT_TYPE_R4 + case 0xD: // ELEMENT_TYPE_R8 + case 0xE: // ELEMENT_TYPE_STRING + case 0x16: // ELEMENT_TYPE_TYPEDBYREF + case 0x18: // ELEMENT_TYPE_I + case 0x19: // ELEMENT_TYPE_U + case 0x1C: // ELEMENT_TYPE_OBJECT + return true; + case 0xF: // ELEMENT_TYPE_PTR + case 0x10: // ELEMENT_TYPE_BYREF + case 0x45: // ELEMENT_TYPE_PINNED + case 0x1D: // ELEMENT_TYPE_SZARRAY + if (!IsSameCompressedInteger(ref a, ref b, out typeCode)) + return false; + if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) + return false; + return true; + case 0x1B: // ELEMENT_TYPE_FNPTR + if (!EqualsMethodSignature(ref a, ref b, contextForA, contextForB)) + return false; + return true; + case 0x14: // ELEMENT_TYPE_ARRAY + // element type + if (!IsSameCompressedInteger(ref a, ref b, out typeCode)) + return false; + if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) + return false; + // rank + if (!IsSameCompressedInteger(ref a, ref b, out _)) + return false; + // sizes + if (!IsSameCompressedInteger(ref a, ref b, out var numOfSizes)) + return false; + for (var i = 0; i < numOfSizes; i++) + { + if (!IsSameCompressedInteger(ref a, ref b, out _)) + return false; + } + // lower bounds + if (!IsSameCompressedInteger(ref a, ref b, out var numOfLowerBounds)) + return false; + for (var i = 0; i < numOfLowerBounds; i++) + { + if (!IsSameCompressedSignedInteger(ref a, ref b, out _)) + return false; + } + return true; + case 0x1F: // ELEMENT_TYPE_CMOD_REQD + case 0x20: // ELEMENT_TYPE_CMOD_OPT + // modifier + if (!TypeHandleEquals(ref a, ref b, contextForA, contextForB)) + return false; + // unmodified type + if (!IsSameCompressedInteger(ref a, ref b, out typeCode)) + return false; + if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) + return false; + return true; + case 0x15: // ELEMENT_TYPE_GENERICINST + // generic type + if (!IsSameCompressedInteger(ref a, ref b, out typeCode)) + return false; + if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) + return false; + if (!IsSameCompressedInteger(ref a, ref b, out var numOfArguments)) + return false; + for (var i = 0; i < numOfArguments; i++) + { + if (!IsSameCompressedInteger(ref a, ref b, out typeCode)) + return false; + if (!TypesAreEqual(ref a, ref b, contextForA, contextForB, typeCode)) + return false; + } + return true; + case 0x13: // ELEMENT_TYPE_VAR + case 0x1E: // ELEMENT_TYPE_MVAR + // index + if (!IsSameCompressedInteger(ref a, ref b, out _)) + return false; + return true; + case 0x11: // ELEMENT_TYPE_VALUETYPE + case 0x12: // ELEMENT_TYPE_CLASS + if (!TypeHandleEquals(ref a, ref b, contextForA, contextForB)) + return false; + return true; + default: + return false; + } + } + + static bool TypeHandleEquals(ref BlobReader a, ref BlobReader b, MetadataReader contextForA, MetadataReader contextForB) + { + var typeA = a.ReadTypeHandle(); + var typeB = b.ReadTypeHandle(); + if (typeA.IsNil || typeB.IsNil) + return false; + return typeA.GetFullTypeName(contextForA) == typeB.GetFullTypeName(contextForB); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/UniversalAssemblyResolver.cs b/src/ICSharpCode.Decompiler/Metadata/UniversalAssemblyResolver.cs new file mode 100644 index 0000000..b41df2d --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/UniversalAssemblyResolver.cs @@ -0,0 +1,690 @@ +// Copyright (c) 2018 Siegfried Pammer +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Reflection.Metadata; +using System.Reflection.PortableExecutable; +using System.Text; +using System.Text.RegularExpressions; + +namespace ICSharpCode.Decompiler.Metadata +{ + public enum TargetFrameworkIdentifier + { + NETFramework, + NETCoreApp, + NETStandard, + Silverlight + } + + enum DecompilerRuntime + { + NETFramework, + NETCoreApp, + Mono + } + + /// + /// Used to resolve assemblies referenced by an assembly. + /// + public class UniversalAssemblyResolver : AssemblyReferenceClassifier, IAssemblyResolver + { + static UniversalAssemblyResolver() + { + // TODO : test whether this works with Mono on *Windows*, not sure if we'll + // ever need this... + if (Type.GetType("Mono.Runtime") != null) + decompilerRuntime = DecompilerRuntime.Mono; + else if (typeof(object).Assembly.GetName().Name == "System.Private.CoreLib") + decompilerRuntime = DecompilerRuntime.NETCoreApp; + else if (Environment.OSVersion.Platform == PlatformID.Unix) + decompilerRuntime = DecompilerRuntime.Mono; + } + + DotNetCorePathFinder dotNetCorePathFinder; + readonly bool throwOnError; + readonly PEStreamOptions streamOptions; + readonly MetadataReaderOptions metadataOptions; + readonly string mainAssemblyFileName; + readonly string baseDirectory; + readonly List directories = new List(); + static readonly List gac_paths = GetGacPaths(); + HashSet targetFrameworkSearchPaths; + static readonly DecompilerRuntime decompilerRuntime; + + public void AddSearchDirectory(string directory) + { + directories.Add(directory); + dotNetCorePathFinder?.AddSearchDirectory(directory); + } + + public void RemoveSearchDirectory(string directory) + { + directories.Remove(directory); + dotNetCorePathFinder?.RemoveSearchDirectory(directory); + } + + public string[] GetSearchDirectories() + { + return directories.ToArray(); + } + + string targetFramework; + TargetFrameworkIdentifier targetFrameworkIdentifier; + Version targetFrameworkVersion; + + /// + /// Creates a new instance of the . + /// + /// + /// The full path to the "main assembly" (i.e., the assembly being decompiled). This is used to + /// resolve assemblies that are located next the main assembly. If no full path is used, the resolver + /// falls back to using . + /// + /// + /// If an is thrown, in case the + /// assembly reference cannot be resolved. + /// + /// + /// The target framework name as used by . + /// That is, "{framework},Version={version}": currently it supports ".NETCoreApp", ".NETStandard" and + /// "Silverlight", if the string doesn't match any of these, the resolver falls back to ".NET Framework", + /// which is "classic" .NET <= 4.8. + /// + /// Options used for the . + /// Options used for the . + public UniversalAssemblyResolver(string mainAssemblyFileName, bool throwOnError, string targetFramework, + PEStreamOptions streamOptions = PEStreamOptions.Default, MetadataReaderOptions metadataOptions = MetadataReaderOptions.Default) + { + this.mainAssemblyFileName = mainAssemblyFileName; + this.throwOnError = throwOnError; + this.streamOptions = streamOptions; + this.metadataOptions = metadataOptions; + this.targetFramework = targetFramework ?? string.Empty; + (targetFrameworkIdentifier, targetFrameworkVersion) = ParseTargetFramework(this.targetFramework); + + if (mainAssemblyFileName != null) + { + var baseDirectory = Path.GetDirectoryName(mainAssemblyFileName); + if (string.IsNullOrWhiteSpace(this.baseDirectory)) + this.baseDirectory = Environment.CurrentDirectory; + AddSearchDirectory(baseDirectory); + } + } + + internal static (TargetFrameworkIdentifier, Version) ParseTargetFramework(string targetFramework) + { + var tokens = targetFramework.Split(','); + TargetFrameworkIdentifier identifier; + + switch (tokens[0].Trim().ToUpperInvariant()) + { + case ".NETCOREAPP": + identifier = TargetFrameworkIdentifier.NETCoreApp; + break; + case ".NETSTANDARD": + identifier = TargetFrameworkIdentifier.NETStandard; + break; + case "SILVERLIGHT": + identifier = TargetFrameworkIdentifier.Silverlight; + break; + default: + identifier = TargetFrameworkIdentifier.NETFramework; + break; + } + + Version version = null; + + for (var i = 1; i < tokens.Length; i++) + { + var pair = tokens[i].Trim().Split('='); + + if (pair.Length != 2) + continue; + + switch (pair[0].Trim().ToUpperInvariant()) + { + case "VERSION": + var versionString = pair[1].TrimStart('v', ' ', '\t'); + if (identifier == TargetFrameworkIdentifier.NETCoreApp || + identifier == TargetFrameworkIdentifier.NETStandard) + { + if (versionString.Length == 3) + versionString += ".0"; + } + if (!Version.TryParse(versionString, out version)) + version = null; + break; + } + } + + return (identifier, version ?? ZeroVersion); + } + +#if !VSADDIN + public PEFile Resolve(IAssemblyReference name) + { + var file = FindAssemblyFile(name); + if (file == null) + { + if (throwOnError) + throw new AssemblyResolutionException(name); + return null; + } + return new PEFile(file, new FileStream(file, FileMode.Open, FileAccess.Read), streamOptions, metadataOptions); + } + + public PEFile ResolveModule(PEFile mainModule, string moduleName) + { + var baseDirectory = Path.GetDirectoryName(mainModule.FileName); + var moduleFileName = Path.Combine(baseDirectory, moduleName); + if (!File.Exists(moduleFileName)) + { + if (throwOnError) + throw new Exception($"Module {moduleName} could not be found!"); + return null; + } + return new PEFile(moduleFileName, new FileStream(moduleFileName, FileMode.Open, FileAccess.Read), streamOptions, metadataOptions); + } +#endif + + public override bool IsSharedAssembly(IAssemblyReference reference, out string runtimePack) + { + return dotNetCorePathFinder.TryResolveDotNetCoreShared(reference, out runtimePack) != null; + } + + public string FindAssemblyFile(IAssemblyReference name) + { + if (name.IsWindowsRuntime) + { + return FindWindowsMetadataFile(name); + } + + string file = null; + switch (targetFrameworkIdentifier) + { + case TargetFrameworkIdentifier.NETCoreApp: + case TargetFrameworkIdentifier.NETStandard: + if (IsZeroOrAllOnes(targetFrameworkVersion)) + goto default; + if (dotNetCorePathFinder == null) + { + if (mainAssemblyFileName == null) + dotNetCorePathFinder = new DotNetCorePathFinder(targetFrameworkIdentifier, targetFrameworkVersion); + else + dotNetCorePathFinder = new DotNetCorePathFinder(mainAssemblyFileName, targetFramework, targetFrameworkIdentifier, targetFrameworkVersion); + foreach (var directory in directories) + { + dotNetCorePathFinder.AddSearchDirectory(directory); + } + } + file = dotNetCorePathFinder.TryResolveDotNetCore(name); + if (file != null) + return file; + goto default; + case TargetFrameworkIdentifier.Silverlight: + if (IsZeroOrAllOnes(targetFrameworkVersion)) + goto default; + file = ResolveSilverlight(name, targetFrameworkVersion); + if (file != null) + return file; + goto default; + default: + return ResolveInternal(name); + } + } + + string FindWindowsMetadataFile(IAssemblyReference name) + { + // Finding Windows Metadata (winmd) is currently only supported on Windows. + if (Environment.OSVersion.Platform != PlatformID.Win32NT) + return null; + + // TODO : Find a way to detect the base directory for the required Windows SDK. + var basePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "Windows Kits", "10", "References"); + + if (!Directory.Exists(basePath)) + return FindWindowsMetadataInSystemDirectory(name); + + // TODO : Find a way to detect the required Windows SDK version. + var di = new DirectoryInfo(basePath); + basePath = null; + foreach (var versionFolder in di.EnumerateDirectories()) + { + basePath = versionFolder.FullName; + } + + if (basePath == null) + return FindWindowsMetadataInSystemDirectory(name); + + basePath = Path.Combine(basePath, name.Name); + + if (!Directory.Exists(basePath)) + return FindWindowsMetadataInSystemDirectory(name); + + basePath = Path.Combine(basePath, FindClosestVersionDirectory(basePath, name.Version)); + + if (!Directory.Exists(basePath)) + return FindWindowsMetadataInSystemDirectory(name); + + var file = Path.Combine(basePath, name.Name + ".winmd"); + + if (!File.Exists(file)) + return FindWindowsMetadataInSystemDirectory(name); + + return file; + } + + string FindWindowsMetadataInSystemDirectory(IAssemblyReference name) + { + var file = Path.Combine(Environment.SystemDirectory, "WinMetadata", name.Name + ".winmd"); + if (File.Exists(file)) + return file; + return null; + } + + void AddTargetFrameworkSearchPathIfExists(string path) + { + if (targetFrameworkSearchPaths == null) + { + targetFrameworkSearchPaths = new HashSet(); + } + if (Directory.Exists(path)) + targetFrameworkSearchPaths.Add(path); + } + + /// + /// This only works on Windows + /// + string ResolveSilverlight(IAssemblyReference name, Version version) + { + AddTargetFrameworkSearchPathIfExists(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Microsoft Silverlight")); + AddTargetFrameworkSearchPathIfExists(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "Microsoft Silverlight")); + + foreach (var baseDirectory in targetFrameworkSearchPaths) + { + var versionDirectory = Path.Combine(baseDirectory, FindClosestVersionDirectory(baseDirectory, version)); + var file = SearchDirectory(name, versionDirectory); + if (file != null) + return file; + } + return null; + } + + string FindClosestVersionDirectory(string basePath, Version version) + { + string path = null; + foreach (var folder in new DirectoryInfo(basePath).GetDirectories().Select(d => DotNetCorePathFinder.ConvertToVersion(d.Name)) + .Where(v => v.Item1 != null).OrderByDescending(v => v.Item1)) + { + if (path == null || folder.Item1 >= version) + path = folder.Item2; + } + return path ?? version.ToString(); + } + + string ResolveInternal(IAssemblyReference name) + { + if (name == null) + throw new ArgumentNullException(nameof(name)); + + var assembly = SearchDirectory(name, directories); + if (assembly != null) + return assembly; + + var framework_dir = Path.GetDirectoryName(typeof(object).Module.FullyQualifiedName); + var framework_dirs = decompilerRuntime == DecompilerRuntime.Mono + ? new[] { framework_dir, Path.Combine(framework_dir, "Facades") } + : new[] { framework_dir }; + + if (IsSpecialVersionOrRetargetable(name)) + { + assembly = SearchDirectory(name, framework_dirs); + if (assembly != null) + return assembly; + } + + if (name.Name == "mscorlib") + { + assembly = GetCorlib(name); + if (assembly != null) + return assembly; + } + + assembly = GetAssemblyInGac(name); + if (assembly != null) + return assembly; + + // when decompiling assemblies that target frameworks prior to 4.0, we can fall back to the 4.0 assemblies in case the target framework is not installed. + // but when looking for Microsoft.Build.Framework, Version=15.0.0.0 we should not use the version 4.0 assembly here so that the LoadedAssembly logic can instead fall back to version 15.1.0.0 + if (name.Version <= new Version(4, 0, 0, 0)) + { + assembly = SearchDirectory(name, framework_dirs); + if (assembly != null) + return assembly; + } + + if (throwOnError) + throw new AssemblyResolutionException(name); + return null; + } + + #region .NET / mono GAC handling + string SearchDirectory(IAssemblyReference name, IEnumerable directories) + { + foreach (var directory in directories) + { + var file = SearchDirectory(name, directory); + if (file != null) + return file; + } + + return null; + } + + static bool IsSpecialVersionOrRetargetable(IAssemblyReference reference) + { + return IsZeroOrAllOnes(reference.Version) || reference.IsRetargetable; + } + + string SearchDirectory(IAssemblyReference name, string directory) + { + var extensions = name.IsWindowsRuntime ? new[] { ".winmd", ".dll" } : new[] { ".exe", ".dll" }; + foreach (var extension in extensions) + { + var file = Path.Combine(directory, name.Name + extension); + if (!File.Exists(file)) + continue; + try + { + return file; + } + catch (BadImageFormatException) + { + continue; + } + } + return null; + } + + static bool IsZeroOrAllOnes(Version version) + { + return version == null + || (version.Major == 0 && version.Minor == 0 && version.Build == 0 && version.Revision == 0) + || (version.Major == 65535 && version.Minor == 65535 && version.Build == 65535 && version.Revision == 65535); + } + + internal static Version ZeroVersion = new Version(0, 0, 0, 0); + + string GetCorlib(IAssemblyReference reference) + { + var version = reference.Version; + var corlib = typeof(object).Assembly.GetName(); + + if (decompilerRuntime != DecompilerRuntime.NETCoreApp) + { + if (corlib.Version == version || IsSpecialVersionOrRetargetable(reference)) + return typeof(object).Module.FullyQualifiedName; + } + + if (reference.PublicKeyToken == null) + return null; + + string path; + if (decompilerRuntime == DecompilerRuntime.Mono) + { + path = GetMonoMscorlibBasePath(version); + } + else + { + path = GetMscorlibBasePath(version, reference.PublicKeyToken.ToHexString(8)); + } + + if (path == null) + return null; + + var file = Path.Combine(path, "mscorlib.dll"); + if (File.Exists(file)) + return file; + + return null; + } + + string GetMscorlibBasePath(Version version, string publicKeyToken) + { + string GetSubFolderForVersion() + { + switch (version.Major) + { + case 1: + if (version.MajorRevision == 3300) + return "v1.0.3705"; + return "v1.1.4322"; + case 2: + return "v2.0.50727"; + case 4: + return "v4.0.30319"; + default: + if (throwOnError) + throw new NotSupportedException("Version not supported: " + version); + return null; + } + } + + if (publicKeyToken == "969db8053d3322ac") + { + var programFiles = Environment.Is64BitOperatingSystem ? + Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86) : + Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles); + var cfPath = $@"Microsoft.NET\SDK\CompactFramework\v{version.Major}.{version.Minor}\WindowsCE\"; + var cfBasePath = Path.Combine(programFiles, cfPath); + if (Directory.Exists(cfBasePath)) + return cfBasePath; + } + else + { + var rootPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Windows), "Microsoft.NET"); + var frameworkPaths = new[] { + Path.Combine(rootPath, "Framework"), + Path.Combine(rootPath, "Framework64") + }; + + var folder = GetSubFolderForVersion(); + + if (folder != null) + { + foreach (var path in frameworkPaths) + { + var basePath = Path.Combine(path, folder); + if (Directory.Exists(basePath)) + return basePath; + } + } + } + + if (throwOnError) + throw new NotSupportedException("Version not supported: " + version); + return null; + } + + string GetMonoMscorlibBasePath(Version version) + { + var path = Directory.GetParent(typeof(object).Module.FullyQualifiedName).Parent.FullName; + if (version.Major == 1) + path = Path.Combine(path, "1.0"); + else if (version.Major == 2) + { + if (version.MajorRevision == 5) + path = Path.Combine(path, "2.1"); + else + path = Path.Combine(path, "2.0"); + } + else if (version.Major == 4) + path = Path.Combine(path, "4.0"); + else + { + if (throwOnError) + throw new NotSupportedException("Version not supported: " + version); + return null; + } + return path; + } + + public static List GetGacPaths() + { + if (decompilerRuntime == DecompilerRuntime.Mono) + return GetDefaultMonoGacPaths(); + + var paths = new List(2); + var windir = Environment.GetFolderPath(Environment.SpecialFolder.Windows); + if (windir == null) + return paths; + + paths.Add(Path.Combine(windir, "assembly")); + paths.Add(Path.Combine(windir, "Microsoft.NET", "assembly")); + return paths; + } + + static List GetDefaultMonoGacPaths() + { + var paths = new List(1); + var gac = GetCurrentMonoGac(); + if (gac != null) + paths.Add(gac); + + var gac_paths_env = Environment.GetEnvironmentVariable("MONO_GAC_PREFIX"); + if (string.IsNullOrEmpty(gac_paths_env)) + return paths; + + var prefixes = gac_paths_env.Split(Path.PathSeparator); + foreach (var prefix in prefixes) + { + if (string.IsNullOrEmpty(prefix)) + continue; + + var gac_path = Path.Combine(Path.Combine(Path.Combine(prefix, "lib"), "mono"), "gac"); + if (Directory.Exists(gac_path) && !paths.Contains(gac)) + paths.Add(gac_path); + } + + return paths; + } + + static string GetCurrentMonoGac() + { + return Path.Combine( + Directory.GetParent( + Path.GetDirectoryName(typeof(object).Module.FullyQualifiedName)).FullName, + "gac"); + } + + public static string GetAssemblyInGac(IAssemblyReference reference) + { + if (reference.PublicKeyToken == null || reference.PublicKeyToken.Length == 0) + return null; + + if (decompilerRuntime == DecompilerRuntime.Mono) + return GetAssemblyInMonoGac(reference); + + return GetAssemblyInNetGac(reference); + } + + static string GetAssemblyInMonoGac(IAssemblyReference reference) + { + for (var i = 0; i < gac_paths.Count; i++) + { + var gac_path = gac_paths[i]; + var file = GetAssemblyFile(reference, string.Empty, gac_path); + if (File.Exists(file)) + return file; + } + + return null; + } + + static string GetAssemblyInNetGac(IAssemblyReference reference) + { + var gacs = new[] { "GAC_MSIL", "GAC_32", "GAC_64", "GAC" }; + var prefixes = new[] { string.Empty, "v4.0_" }; + + for (var i = 0; i < gac_paths.Count; i++) + { + for (var j = 0; j < gacs.Length; j++) + { + var gac = Path.Combine(gac_paths[i], gacs[j]); + var file = GetAssemblyFile(reference, prefixes[i], gac); + if (Directory.Exists(gac) && File.Exists(file)) + return file; + } + } + + return null; + } + + static string GetAssemblyFile(IAssemblyReference reference, string prefix, string gac) + { + var gac_folder = new StringBuilder() + .Append(prefix) + .Append(reference.Version) + .Append("__"); + + for (var i = 0; i < reference.PublicKeyToken.Length; i++) + gac_folder.Append(reference.PublicKeyToken[i].ToString("x2")); + + return Path.Combine( + Path.Combine( + Path.Combine(gac, reference.Name), gac_folder.ToString()), + reference.Name + ".dll"); + } + + /// + /// Gets the names of all assemblies in the GAC. + /// + public static IEnumerable EnumerateGac() + { + var gacs = new[] { "GAC_MSIL", "GAC_32", "GAC_64", "GAC" }; + foreach (var path in GetGacPaths()) + { + foreach (var gac in gacs) + { + var rootPath = Path.Combine(path, gac); + if (!Directory.Exists(rootPath)) + continue; + foreach (var item in new DirectoryInfo(rootPath).EnumerateFiles("*.dll", SearchOption.AllDirectories)) + { + var name = Path.GetDirectoryName(item.FullName).Substring(rootPath.Length + 1).Split(new[] { "\\" }, StringSplitOptions.RemoveEmptyEntries); + if (name.Length != 2) + continue; + var match = Regex.Match(name[1], $"(v4.0_)?(?[^_]+)_(?[^_]+)?_(?[^_]+)"); + if (!match.Success) + continue; + var culture = match.Groups["culture"].Value; + if (string.IsNullOrEmpty(culture)) + culture = "neutral"; + yield return AssemblyNameReference.Parse(name[0] + ", Version=" + match.Groups["version"].Value + ", Culture=" + culture + ", PublicKeyToken=" + match.Groups["publicKey"].Value); + } + } + } + } + + #endregion + } +} diff --git a/src/ICSharpCode.Decompiler/Metadata/UnresolvedAssemblyNameReference.cs b/src/ICSharpCode.Decompiler/Metadata/UnresolvedAssemblyNameReference.cs new file mode 100644 index 0000000..0ec7fac --- /dev/null +++ b/src/ICSharpCode.Decompiler/Metadata/UnresolvedAssemblyNameReference.cs @@ -0,0 +1,39 @@ +// Copyright (c) 2018 Siegfried Pammer +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Linq; + +namespace ICSharpCode.Decompiler.Metadata +{ + public sealed class UnresolvedAssemblyNameReference + { + public string FullName { get; } + + public bool HasErrors => Messages.Any(m => m.Item1 == MessageKind.Error); + + public List<(MessageKind, string)> Messages { get; } = new List<(MessageKind, string)>(); + + public UnresolvedAssemblyNameReference(string fullName) + { + this.FullName = fullName; + } + } + + public enum MessageKind { Error, Warning, Info } +} diff --git a/src/ICSharpCode.Decompiler/NRExtensions.cs b/src/ICSharpCode.Decompiler/NRExtensions.cs new file mode 100644 index 0000000..8d93844 --- /dev/null +++ b/src/ICSharpCode.Decompiler/NRExtensions.cs @@ -0,0 +1,102 @@ +// Copyright (c) 2015 Siegfried Pammer +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. +using System; + +using ICSharpCode.Decompiler.Documentation; +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler +{ + public static class NRExtensions + { + public static bool IsCompilerGenerated(this IEntity entity) + { + if (entity != null) + { + return entity.HasAttribute(KnownAttribute.CompilerGenerated); + } + return false; + } + + public static bool IsCompilerGeneratedOrIsInCompilerGeneratedClass(this IEntity entity) + { + if (entity == null) + return false; + if (entity.IsCompilerGenerated()) + return true; + return IsCompilerGeneratedOrIsInCompilerGeneratedClass(entity.DeclaringTypeDefinition); + } + + public static bool HasGeneratedName(this IMember member) + { + return member.Name.StartsWith("<", StringComparison.Ordinal); + } + + public static bool HasGeneratedName(this IType type) + { + return type.Name.StartsWith("<", StringComparison.Ordinal) || type.Name.Contains("<"); + } + + public static bool IsAnonymousType(this IType type) + { + if (type == null) + return false; + if (string.IsNullOrEmpty(type.Namespace) && type.HasGeneratedName() + && (type.Name.Contains("AnonType") || type.Name.Contains("AnonymousType"))) + { + var td = type.GetDefinition(); + return td != null && td.IsCompilerGenerated(); + } + return false; + } + + public static bool ContainsAnonymousType(this IType type) + { + var visitor = new ContainsAnonTypeVisitor(); + type.AcceptVisitor(visitor); + return visitor.ContainsAnonType; + } + + class ContainsAnonTypeVisitor : TypeVisitor + { + public bool ContainsAnonType; + + public override IType VisitOtherType(IType type) + { + if (IsAnonymousType(type)) + ContainsAnonType = true; + return base.VisitOtherType(type); + } + + public override IType VisitTypeDefinition(ITypeDefinition type) + { + if (IsAnonymousType(type)) + ContainsAnonType = true; + return base.VisitTypeDefinition(type); + } + } + + internal static string GetDocumentation(this IEntity entity) + { + var docProvider = XmlDocLoader.LoadDocumentation(entity.ParentModule.PEFile); + if (docProvider == null) + return null; + return docProvider.GetDocumentation(entity); + } + } +} diff --git a/src/ICSharpCode.Decompiler/OpCodeInfo.cs b/src/ICSharpCode.Decompiler/OpCodeInfo.cs new file mode 100644 index 0000000..31492c6 --- /dev/null +++ b/src/ICSharpCode.Decompiler/OpCodeInfo.cs @@ -0,0 +1,108 @@ +// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler.Disassembler +{ + public struct OpCodeInfo : IEquatable + { + public readonly ILOpCode Code; + public readonly string Name; + + string encodedName; + + public OpCodeInfo(ILOpCode code, string name) + { + this.Code = code; + this.Name = name ?? ""; + this.encodedName = null; + } + + public bool Equals(OpCodeInfo other) + { + return other.Code == this.Code && other.Name == this.Name; + } + + public static bool operator ==(OpCodeInfo lhs, OpCodeInfo rhs) => lhs.Equals(rhs); + public static bool operator !=(OpCodeInfo lhs, OpCodeInfo rhs) => !(lhs == rhs); + + public override bool Equals(object obj) + { + if (obj is OpCodeInfo opCode) + return Equals(opCode); + return false; + } + + public override int GetHashCode() + { + return unchecked(982451629 * Code.GetHashCode() + 982451653 * Name.GetHashCode()); + } + + public string Link => "https://docs.microsoft.com/dotnet/api/system.reflection.emit.opcodes." + EncodedName.ToLowerInvariant(); + public string EncodedName { + get { + if (encodedName != null) + return encodedName; + switch (Name) + { + case "constrained.": + encodedName = "Constrained"; + return encodedName; + case "no.": + encodedName = "No"; + return encodedName; + case "readonly.": + encodedName = "Reaonly"; + return encodedName; + case "tail.": + encodedName = "Tailcall"; + return encodedName; + case "unaligned.": + encodedName = "Unaligned"; + return encodedName; + case "volatile.": + encodedName = "Volatile"; + return encodedName; + } + var text = ""; + var toUpperCase = true; + foreach (var ch in Name) + { + if (ch == '.') + { + text += '_'; + toUpperCase = true; + } + else if (toUpperCase) + { + text += char.ToUpperInvariant(ch); + toUpperCase = false; + } + else + { + text += ch; + } + } + encodedName = text; + return encodedName; + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/SRMExtensions.cs b/src/ICSharpCode.Decompiler/SRMExtensions.cs new file mode 100644 index 0000000..9a17974 --- /dev/null +++ b/src/ICSharpCode.Decompiler/SRMExtensions.cs @@ -0,0 +1,596 @@ +using System; +using System.Collections.Immutable; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Reflection.PortableExecutable; + +using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.Util; + +using SRM = System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler +{ + public static partial class SRMExtensions + { + public static bool HasFlag(this TypeDefinition typeDefinition, TypeAttributes attribute) + => (typeDefinition.Attributes & attribute) == attribute; + public static bool HasFlag(this MethodDefinition methodDefinition, MethodAttributes attribute) + => (methodDefinition.Attributes & attribute) == attribute; + public static bool HasFlag(this FieldDefinition fieldDefinition, FieldAttributes attribute) + => (fieldDefinition.Attributes & attribute) == attribute; + public static bool HasFlag(this PropertyDefinition propertyDefinition, PropertyAttributes attribute) + => (propertyDefinition.Attributes & attribute) == attribute; + public static bool HasFlag(this EventDefinition eventDefinition, EventAttributes attribute) + => (eventDefinition.Attributes & attribute) == attribute; + + public static bool IsTypeKind(this HandleKind kind) => + kind == HandleKind.TypeDefinition || kind == HandleKind.TypeReference + || kind == HandleKind.TypeSpecification; + public static bool IsMemberKind(this HandleKind kind) => + kind == HandleKind.MethodDefinition || kind == HandleKind.PropertyDefinition + || kind == HandleKind.FieldDefinition || kind == HandleKind.EventDefinition + || kind == HandleKind.MemberReference || kind == HandleKind.MethodSpecification; + public static bool IsEntityHandle(this Handle handle) => + handle.IsNil || (byte)handle.Kind < 112; + + public static bool IsValueType(this TypeDefinitionHandle handle, MetadataReader reader) + { + return reader.GetTypeDefinition(handle).IsValueType(reader); + } + + public static bool IsValueType(this TypeDefinition typeDefinition, MetadataReader reader) + { + var baseType = typeDefinition.GetBaseTypeOrNil(); + if (baseType.IsNil) + return false; + if (baseType.IsKnownType(reader, KnownTypeCode.Enum)) + return true; + if (!baseType.IsKnownType(reader, KnownTypeCode.ValueType)) + return false; + var thisType = typeDefinition.GetFullTypeName(reader); + return !thisType.IsKnownType(KnownTypeCode.Enum); + } + + public static bool IsEnum(this TypeDefinitionHandle handle, MetadataReader reader) + { + return reader.GetTypeDefinition(handle).IsEnum(reader); + } + + public static bool IsEnum(this TypeDefinition typeDefinition, MetadataReader reader) + { + var baseType = typeDefinition.GetBaseTypeOrNil(); + if (baseType.IsNil) + return false; + return baseType.IsKnownType(reader, KnownTypeCode.Enum); + } + + public static bool IsEnum(this TypeDefinitionHandle handle, MetadataReader reader, + out PrimitiveTypeCode underlyingType) + { + return reader.GetTypeDefinition(handle).IsEnum(reader, out underlyingType); + } + + public static bool IsEnum(this TypeDefinition typeDefinition, MetadataReader reader, + out PrimitiveTypeCode underlyingType) + { + underlyingType = 0; + EntityHandle baseType = typeDefinition.GetBaseTypeOrNil(); + if (baseType.IsNil) + return false; + if (!baseType.IsKnownType(reader, KnownTypeCode.Enum)) + return false; + foreach (var handle in typeDefinition.GetFields()) + { + var field = reader.GetFieldDefinition(handle); + if ((field.Attributes & FieldAttributes.Static) != 0) + continue; + var blob = reader.GetBlobReader(field.Signature); + if (blob.ReadSignatureHeader().Kind != SignatureKind.Field) + return false; + underlyingType = (PrimitiveTypeCode)blob.ReadByte(); + return true; + } + return false; + } + + public static bool IsDelegate(this TypeDefinitionHandle handle, MetadataReader reader) + { + return reader.GetTypeDefinition(handle).IsDelegate(reader); + } + + public static bool IsDelegate(this TypeDefinition typeDefinition, MetadataReader reader) + { + var baseType = typeDefinition.GetBaseTypeOrNil(); + return !baseType.IsNil && baseType.IsKnownType(reader, KnownTypeCode.MulticastDelegate); + } + + public static bool HasBody(this MethodDefinition methodDefinition) + { + const MethodAttributes noBodyAttrs = MethodAttributes.Abstract | MethodAttributes.PinvokeImpl; + const MethodImplAttributes noBodyImplAttrs = MethodImplAttributes.InternalCall + | MethodImplAttributes.Native | MethodImplAttributes.Unmanaged | MethodImplAttributes.Runtime; + return (methodDefinition.Attributes & noBodyAttrs) == 0 && + (methodDefinition.ImplAttributes & noBodyImplAttrs) == 0 && + methodDefinition.RelativeVirtualAddress > 0; + } + + public static int GetCodeSize(this MethodBodyBlock body) + { + if (body == null) + throw new ArgumentNullException(nameof(body)); + + return body.GetILReader().Length; + } + + public static MethodDefinitionHandle GetAny(this PropertyAccessors accessors) + { + if (!accessors.Getter.IsNil) + return accessors.Getter; + return accessors.Setter; + } + + public static MethodDefinitionHandle GetAny(this EventAccessors accessors) + { + if (!accessors.Adder.IsNil) + return accessors.Adder; + if (!accessors.Remover.IsNil) + return accessors.Remover; + return accessors.Raiser; + } + + public static TypeDefinitionHandle GetDeclaringType(this EntityHandle entity, MetadataReader metadata) + { + switch (entity.Kind) + { + case HandleKind.TypeDefinition: + var td = metadata.GetTypeDefinition((TypeDefinitionHandle)entity); + return td.GetDeclaringType(); + case HandleKind.FieldDefinition: + var fd = metadata.GetFieldDefinition((FieldDefinitionHandle)entity); + return fd.GetDeclaringType(); + case HandleKind.MethodDefinition: + var md = metadata.GetMethodDefinition((MethodDefinitionHandle)entity); + return md.GetDeclaringType(); + case HandleKind.EventDefinition: + var ed = metadata.GetEventDefinition((EventDefinitionHandle)entity); + return metadata.GetMethodDefinition(ed.GetAccessors().GetAny()).GetDeclaringType(); + case HandleKind.PropertyDefinition: + var pd = metadata.GetPropertyDefinition((PropertyDefinitionHandle)entity); + return metadata.GetMethodDefinition(pd.GetAccessors().GetAny()).GetDeclaringType(); + default: + throw new ArgumentOutOfRangeException(); + } + } + + public static TypeReferenceHandle GetDeclaringType(this TypeReference tr) + { + switch (tr.ResolutionScope.Kind) + { + case HandleKind.TypeReference: + return (TypeReferenceHandle)tr.ResolutionScope; + default: + return default(TypeReferenceHandle); + } + } + + public static FullTypeName GetFullTypeName(this EntityHandle handle, MetadataReader reader) + { + if (handle.IsNil) + throw new ArgumentNullException(nameof(handle)); + switch (handle.Kind) + { + case HandleKind.TypeDefinition: + return ((TypeDefinitionHandle)handle).GetFullTypeName(reader); + case HandleKind.TypeReference: + return ((TypeReferenceHandle)handle).GetFullTypeName(reader); + case HandleKind.TypeSpecification: + return ((TypeSpecificationHandle)handle).GetFullTypeName(reader); + default: + throw new ArgumentOutOfRangeException(); + } + } + + public static bool IsKnownType(this EntityHandle handle, MetadataReader reader, + KnownTypeCode knownType) + { + return !handle.IsNil + && GetFullTypeName(handle, reader) == KnownTypeReference.Get(knownType).TypeName; + } + + internal static bool IsKnownType(this EntityHandle handle, MetadataReader reader, + KnownAttribute knownType) + { + return !handle.IsNil + && GetFullTypeName(handle, reader) == knownType.GetTypeName(); + } + + public static FullTypeName GetFullTypeName(this TypeSpecificationHandle handle, MetadataReader reader) + { + if (handle.IsNil) + throw new ArgumentNullException(nameof(handle)); + var ts = reader.GetTypeSpecification(handle); + return ts.DecodeSignature(new Metadata.FullTypeNameSignatureDecoder(reader), default(Unit)); + } + + public static FullTypeName GetFullTypeName(this TypeReferenceHandle handle, MetadataReader reader) + { + if (handle.IsNil) + throw new ArgumentNullException(nameof(handle)); + var tr = reader.GetTypeReference(handle); + string name; + try + { + name = reader.GetString(tr.Name); + } + catch (BadImageFormatException) + { + name = $"TR{reader.GetToken(handle):x8}"; + } + name = ReflectionHelper.SplitTypeParameterCountFromReflectionName( + name, out var typeParameterCount); + TypeReferenceHandle declaringTypeHandle; + try + { + declaringTypeHandle = tr.GetDeclaringType(); + } + catch (BadImageFormatException) + { + declaringTypeHandle = default; + } + if (declaringTypeHandle.IsNil) + { + string ns; + try + { + ns = tr.Namespace.IsNil ? "" : reader.GetString(tr.Namespace); + } + catch (BadImageFormatException) + { + ns = ""; + } + return new FullTypeName(new TopLevelTypeName(ns, name, typeParameterCount)); + } + else + { + return declaringTypeHandle.GetFullTypeName(reader).NestedType(name, typeParameterCount); + } + } + + public static FullTypeName GetFullTypeName(this TypeDefinitionHandle handle, MetadataReader reader) + { + if (handle.IsNil) + throw new ArgumentNullException(nameof(handle)); + return reader.GetTypeDefinition(handle).GetFullTypeName(reader); + } + + public static FullTypeName GetFullTypeName(this TypeDefinition td, MetadataReader reader) + { + TypeDefinitionHandle declaringTypeHandle; + var name = ReflectionHelper.SplitTypeParameterCountFromReflectionName( + reader.GetString(td.Name), out var typeParameterCount); + if ((declaringTypeHandle = td.GetDeclaringType()).IsNil) + { + var @namespace = td.Namespace.IsNil ? "" : reader.GetString(td.Namespace); + return new FullTypeName(new TopLevelTypeName(@namespace, name, typeParameterCount)); + } + else + { + return declaringTypeHandle.GetFullTypeName(reader).NestedType(name, typeParameterCount); + } + } + + public static FullTypeName GetFullTypeName(this ExportedType type, MetadataReader metadata) + { + var name = ReflectionHelper.SplitTypeParameterCountFromReflectionName( + metadata.GetString(type.Name), out var typeParameterCount); + if (type.Implementation.Kind == HandleKind.ExportedType) + { + var outerType = metadata.GetExportedType((ExportedTypeHandle)type.Implementation); + return outerType.GetFullTypeName(metadata).NestedType(name, typeParameterCount); + } + else + { + var ns = type.Namespace.IsNil ? "" : metadata.GetString(type.Namespace); + return new TopLevelTypeName(ns, name, typeParameterCount); + } + } + + public static bool IsAnonymousType(this TypeDefinition type, MetadataReader metadata) + { + var name = metadata.GetString(type.Name); + if (type.Namespace.IsNil && type.HasGeneratedName(metadata) + && (name.Contains("AnonType") || name.Contains("AnonymousType"))) + { + return type.IsCompilerGenerated(metadata); + } + return false; + } + + #region HasGeneratedName + + public static bool IsGeneratedName(this StringHandle handle, MetadataReader metadata) + { + return !handle.IsNil + && (metadata.GetString(handle).StartsWith("<", StringComparison.Ordinal) + || metadata.GetString(handle).Contains("$")); + } + + public static bool HasGeneratedName(this MethodDefinitionHandle handle, MetadataReader metadata) + { + return metadata.GetMethodDefinition(handle).Name.IsGeneratedName(metadata); + } + + public static bool HasGeneratedName(this TypeDefinitionHandle handle, MetadataReader metadata) + { + return metadata.GetTypeDefinition(handle).Name.IsGeneratedName(metadata); + } + + public static bool HasGeneratedName(this TypeDefinition type, MetadataReader metadata) + { + return type.Name.IsGeneratedName(metadata); + } + + public static bool HasGeneratedName(this FieldDefinitionHandle handle, MetadataReader metadata) + { + return metadata.GetFieldDefinition(handle).Name.IsGeneratedName(metadata); + } + + #endregion + + #region IsCompilerGenerated + + public static bool IsCompilerGenerated(this MethodDefinitionHandle handle, MetadataReader metadata) + { + return metadata.GetMethodDefinition(handle).IsCompilerGenerated(metadata); + } + + public static bool IsCompilerGeneratedOrIsInCompilerGeneratedClass(this MethodDefinitionHandle handle, + MetadataReader metadata) + { + var method = metadata.GetMethodDefinition(handle); + if (method.IsCompilerGenerated(metadata)) + return true; + var declaringTypeHandle = method.GetDeclaringType(); + if (!declaringTypeHandle.IsNil && declaringTypeHandle.IsCompilerGenerated(metadata)) + return true; + return false; + } + + public static bool IsCompilerGeneratedOrIsInCompilerGeneratedClass(this TypeDefinitionHandle handle, + MetadataReader metadata) + { + var type = metadata.GetTypeDefinition(handle); + if (type.IsCompilerGenerated(metadata)) + return true; + var declaringTypeHandle = type.GetDeclaringType(); + if (!declaringTypeHandle.IsNil && declaringTypeHandle.IsCompilerGenerated(metadata)) + return true; + return false; + } + + public static bool IsCompilerGenerated(this MethodDefinition method, MetadataReader metadata) + { + return method.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.CompilerGenerated); + } + + public static bool IsCompilerGenerated(this FieldDefinitionHandle handle, MetadataReader metadata) + { + return metadata.GetFieldDefinition(handle).IsCompilerGenerated(metadata); + } + + public static bool IsCompilerGenerated(this FieldDefinition field, MetadataReader metadata) + { + return field.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.CompilerGenerated); + } + + public static bool IsCompilerGenerated(this TypeDefinitionHandle handle, MetadataReader metadata) + { + return metadata.GetTypeDefinition(handle).IsCompilerGenerated(metadata); + } + + public static bool IsCompilerGenerated(this TypeDefinition type, MetadataReader metadata) + { + return type.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.CompilerGenerated); + } + + #endregion + + #region Attribute extensions + /// + /// Gets the type of the attribute. + /// + public static EntityHandle GetAttributeType(this SRM.CustomAttribute attribute, MetadataReader reader) + { + switch (attribute.Constructor.Kind) + { + case HandleKind.MethodDefinition: + var md = reader.GetMethodDefinition((MethodDefinitionHandle)attribute.Constructor); + return md.GetDeclaringType(); + case HandleKind.MemberReference: + var mr = reader.GetMemberReference((MemberReferenceHandle)attribute.Constructor); + return mr.Parent; + default: + throw new BadImageFormatException("Unexpected token kind for attribute constructor: " + + attribute.Constructor.Kind); + } + } + + public static bool HasKnownAttribute(this CustomAttributeHandleCollection customAttributes, + MetadataReader metadata, KnownAttribute type) + { + foreach (var handle in customAttributes) + { + var customAttribute = metadata.GetCustomAttribute(handle); + if (customAttribute.IsKnownAttribute(metadata, type)) + return true; + } + return false; + } + + internal static bool IsKnownAttribute(this SRM.CustomAttribute attr, MetadataReader metadata, + KnownAttribute attrType) + { + return attr.GetAttributeType(metadata).IsKnownType(metadata, attrType); + } + + public static Nullability? GetNullableContext(this CustomAttributeHandleCollection customAttributes, + MetadataReader metadata) + { + foreach (var handle in customAttributes) + { + var customAttribute = metadata.GetCustomAttribute(handle); + if (customAttribute.IsKnownAttribute(metadata, KnownAttribute.NullableContext)) + { + // Decode + CustomAttributeValue value; + try + { + value = customAttribute.DecodeValue( + Metadata.MetadataExtensions.MinimalAttributeTypeProvider); + } + catch (BadImageFormatException) + { + continue; + } + catch (Metadata.EnumUnderlyingTypeResolveException) + { + continue; + } + if (value.FixedArguments.Length == 1 && value.FixedArguments[0].Value is byte b && b <= 2) + { + return (Nullability)b; + } + } + } + return null; + } + #endregion + + public static unsafe BlobReader GetInitialValue(this FieldDefinition field, PEReader pefile, + ICompilation typeSystem) + { + if (!field.HasFlag(FieldAttributes.HasFieldRVA)) + return default; + var rva = field.GetRelativeVirtualAddress(); + if (rva == 0) + return default; + var size = field.DecodeSignature(new FieldValueSizeDecoder(typeSystem), default); + var sectionData = pefile.GetSectionData(rva); + if (sectionData.Length == 0 && size != 0) + throw new BadImageFormatException($"Field data (rva=0x{rva:x}) could not be found" + + "in any section!"); + if (size < 0 || size > sectionData.Length) + throw new BadImageFormatException($"Invalid size {size} for field data!"); + return sectionData.GetReader(0, size); + } + + sealed class FieldValueSizeDecoder : ISignatureTypeProvider + { + readonly MetadataModule module; + readonly int pointerSize; + + public FieldValueSizeDecoder(ICompilation typeSystem = null) + { + this.module = (MetadataModule)typeSystem?.MainModule; + if (module == null) + this.pointerSize = IntPtr.Size; + else + this.pointerSize = module.PEFile.Reader.PEHeaders.PEHeader.Magic == PEMagic.PE32 ? 4 : 8; + } + + public int GetArrayType(int elementType, ArrayShape shape) => + GetPrimitiveType(PrimitiveTypeCode.Object); + public int GetSZArrayType(int elementType) => GetPrimitiveType(PrimitiveTypeCode.Object); + public int GetByReferenceType(int elementType) => pointerSize; + public int GetFunctionPointerType(MethodSignature signature) => pointerSize; + public int GetGenericInstantiation(int genericType, ImmutableArray typeArguments) + => genericType; + public int GetGenericMethodParameter(GenericContext genericContext, int index) => 0; + public int GetGenericTypeParameter(GenericContext genericContext, int index) => 0; + public int GetModifiedType(int modifier, int unmodifiedType, bool isRequired) => unmodifiedType; + public int GetPinnedType(int elementType) => elementType; + public int GetPointerType(int elementType) => pointerSize; + + public int GetPrimitiveType(PrimitiveTypeCode typeCode) + { + switch (typeCode) + { + case PrimitiveTypeCode.Boolean: + case PrimitiveTypeCode.Byte: + case PrimitiveTypeCode.SByte: + return 1; + case PrimitiveTypeCode.Char: + case PrimitiveTypeCode.Int16: + case PrimitiveTypeCode.UInt16: + return 2; + case PrimitiveTypeCode.Int32: + case PrimitiveTypeCode.UInt32: + case PrimitiveTypeCode.Single: + return 4; + case PrimitiveTypeCode.Int64: + case PrimitiveTypeCode.UInt64: + case PrimitiveTypeCode.Double: + return 8; + case PrimitiveTypeCode.IntPtr: + case PrimitiveTypeCode.UIntPtr: + return pointerSize; + default: + return 0; + } + } + + public int GetTypeFromDefinition(MetadataReader reader, TypeDefinitionHandle handle, + byte rawTypeKind) + { + var td = reader.GetTypeDefinition(handle); + return td.GetLayout().Size; + } + + public int GetTypeFromReference(MetadataReader reader, TypeReferenceHandle handle, + byte rawTypeKind) + { + var typeDef = module?.ResolveType(handle, new GenericContext()).GetDefinition(); + if (typeDef == null || typeDef.MetadataToken.IsNil) + return 0; + reader = typeDef.ParentModule.PEFile.Metadata; + var td = reader.GetTypeDefinition((TypeDefinitionHandle)typeDef.MetadataToken); + return td.GetLayout().Size; + } + + public int GetTypeFromSpecification(MetadataReader reader, GenericContext genericContext, + TypeSpecificationHandle handle, byte rawTypeKind) + { + return reader.GetTypeSpecification(handle).DecodeSignature(this, genericContext); + } + } + + public static EntityHandle GetBaseTypeOrNil(this TypeDefinition definition) + { + try + { + return definition.BaseType; + } + catch (BadImageFormatException) + { + return default; + } + } + + public static string ToILSyntax(this SignatureCallingConvention callConv) + { + return callConv switch + { + SignatureCallingConvention.Default => "default", + SignatureCallingConvention.CDecl => "unmanaged cdecl", + SignatureCallingConvention.StdCall => "unmanaged stdcall", + SignatureCallingConvention.ThisCall => "unmanaged thiscall", + SignatureCallingConvention.FastCall => "unmanaged fastcall", + SignatureCallingConvention.VarArgs => "vararg", + SignatureCallingConvention.Unmanaged => "unmanaged", + _ => callConv.ToString().ToLowerInvariant() + }; + } + } +} diff --git a/src/ICSharpCode.Decompiler/SRMHacks.cs b/src/ICSharpCode.Decompiler/SRMHacks.cs new file mode 100644 index 0000000..b229aa7 --- /dev/null +++ b/src/ICSharpCode.Decompiler/SRMHacks.cs @@ -0,0 +1,27 @@ +using System.Collections.Immutable; +using System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler +{ + public static partial class SRMExtensions + { + public static ImmutableArray GetMethodImplementations( + this MethodDefinitionHandle handle, MetadataReader reader) + { + var resultBuilder = ImmutableArray.CreateBuilder(); + var typeDefinition = reader.GetTypeDefinition(reader.GetMethodDefinition(handle) + .GetDeclaringType()); + + foreach (var methodImplementationHandle in typeDefinition.GetMethodImplementations()) + { + var methodImplementation = reader.GetMethodImplementation(methodImplementationHandle); + if (methodImplementation.MethodBody == handle) + { + resultBuilder.Add(methodImplementationHandle); + } + } + + return resultBuilder.ToImmutable(); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/AmbiguousResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/AmbiguousResolveResult.cs new file mode 100644 index 0000000..51e7435 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/AmbiguousResolveResult.cs @@ -0,0 +1,50 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents an ambiguous type resolve result. + /// + public class AmbiguousTypeResolveResult : TypeResolveResult + { + public AmbiguousTypeResolveResult(IType type) : base(type) + { + } + + public override bool IsError { + get { return true; } + } + } + + /// + /// Represents an ambiguous field/property/event access. + /// + public class AmbiguousMemberResolveResult : MemberResolveResult + { + public AmbiguousMemberResolveResult(ResolveResult targetResult, IMember member) : base(targetResult, member) + { + } + + public override bool IsError { + get { return true; } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/ArrayAccessResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/ArrayAccessResolveResult.cs new file mode 100644 index 0000000..f4a610a --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/ArrayAccessResolveResult.cs @@ -0,0 +1,50 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Resolve result representing an array access. + /// + public class ArrayAccessResolveResult : ResolveResult + { + public readonly ResolveResult Array; + public readonly IList Indexes; + + public ArrayAccessResolveResult(IType elementType, ResolveResult array, IList indexes) : base(elementType) + { + if (array == null) + throw new ArgumentNullException(nameof(array)); + if (indexes == null) + throw new ArgumentNullException(nameof(indexes)); + this.Array = array; + this.Indexes = indexes; + } + + public override IEnumerable GetChildResults() + { + return new[] { Array }.Concat(Indexes); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/ArrayCreateResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/ArrayCreateResolveResult.cs new file mode 100644 index 0000000..624fce7 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/ArrayCreateResolveResult.cs @@ -0,0 +1,60 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Resolve result representing an array creation. + /// + public class ArrayCreateResolveResult : ResolveResult + { + /// + /// Gets the size arguments. + /// + public readonly IReadOnlyList SizeArguments; + + /// + /// Gets the initializer elements. + /// This field may be null if no initializer was specified. + /// + public readonly IReadOnlyList InitializerElements; + + public ArrayCreateResolveResult(IType arrayType, IReadOnlyList sizeArguments, IReadOnlyList initializerElements) + : base(arrayType) + { + if (sizeArguments == null) + throw new ArgumentNullException(nameof(sizeArguments)); + this.SizeArguments = sizeArguments; + this.InitializerElements = initializerElements; + } + + public override IEnumerable GetChildResults() + { + if (InitializerElements != null) + return SizeArguments.Concat(InitializerElements); + else + return SizeArguments; + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/ByReferenceResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/ByReferenceResolveResult.cs new file mode 100644 index 0000000..97918b3 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/ByReferenceResolveResult.cs @@ -0,0 +1,68 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Globalization; +using System.Linq; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents the resolve result of an 'ref x', 'in x' or 'out x' expression. + /// + public class ByReferenceResolveResult : ResolveResult + { + public ReferenceKind ReferenceKind { get; } + public bool IsOut => ReferenceKind == ReferenceKind.Out; + public bool IsRef => ReferenceKind == ReferenceKind.Ref; + public bool IsIn => ReferenceKind == ReferenceKind.In; + + public readonly ResolveResult ElementResult; + + public ByReferenceResolveResult(ResolveResult elementResult, ReferenceKind kind) + : this(elementResult.Type, kind) + { + this.ElementResult = elementResult; + } + + public ByReferenceResolveResult(IType elementType, ReferenceKind kind) + : base(new ByReferenceType(elementType)) + { + this.ReferenceKind = kind; + } + + public IType ElementType { + get { return ((ByReferenceType)this.Type).ElementType; } + } + + public override IEnumerable GetChildResults() + { + if (ElementResult != null) + return new[] { ElementResult }; + else + return Enumerable.Empty(); + } + + public override string ToString() + { + return string.Format(CultureInfo.InvariantCulture, "[{0} {1} {2}]", GetType().Name, ReferenceKind.ToString().ToLowerInvariant(), ElementType); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/ConstantResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/ConstantResolveResult.cs new file mode 100644 index 0000000..d475de1 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/ConstantResolveResult.cs @@ -0,0 +1,55 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Globalization; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// ResolveResult representing a compile-time constant. + /// Note: this class is mainly used for literals; there may be other ResolveResult classes + /// which are compile-time constants as well. + /// For example, a reference to a const field results in a . + /// + /// Check to determine is a resolve result is a constant. + /// + public class ConstantResolveResult : ResolveResult + { + object constantValue; + + public ConstantResolveResult(IType type, object constantValue) : base(type) + { + this.constantValue = constantValue; + } + + public override bool IsCompileTimeConstant { + get { return true; } + } + + public override object ConstantValue { + get { return constantValue; } + } + + public override string ToString() + { + return string.Format(CultureInfo.InvariantCulture, "[{0} {1} = {2}]", GetType().Name, this.Type, constantValue); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/Conversion.cs b/src/ICSharpCode.Decompiler/Semantics/Conversion.cs new file mode 100644 index 0000000..d01fdf5 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/Conversion.cs @@ -0,0 +1,639 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Immutable; +using System.Linq; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Holds information about a conversion between two types. + /// + public abstract class Conversion : IEquatable + { + #region Conversion factory methods + /// + /// Not a valid conversion. + /// + public static readonly Conversion None = new InvalidConversion(); + + /// + /// Identity conversion. + /// + public static readonly Conversion IdentityConversion = new BuiltinConversion(true, 0); + + public static readonly Conversion ImplicitNumericConversion = new NumericOrEnumerationConversion(true, false); + public static readonly Conversion ExplicitNumericConversion = new NumericOrEnumerationConversion(false, false); + public static readonly Conversion ImplicitLiftedNumericConversion = new NumericOrEnumerationConversion(true, true); + public static readonly Conversion ExplicitLiftedNumericConversion = new NumericOrEnumerationConversion(false, true); + + public static Conversion EnumerationConversion(bool isImplicit, bool isLifted) + { + return new NumericOrEnumerationConversion(isImplicit, isLifted, true); + } + + public static readonly Conversion NullLiteralConversion = new BuiltinConversion(true, 1); + + /// + /// The numeric conversion of a constant expression. + /// + public static readonly Conversion ImplicitConstantExpressionConversion = new BuiltinConversion(true, 2); + + public static readonly Conversion ImplicitReferenceConversion = new BuiltinConversion(true, 3); + public static readonly Conversion ExplicitReferenceConversion = new BuiltinConversion(false, 3); + + public static readonly Conversion ImplicitDynamicConversion = new BuiltinConversion(true, 4); + public static readonly Conversion ExplicitDynamicConversion = new BuiltinConversion(false, 4); + + public static readonly Conversion ImplicitNullableConversion = new BuiltinConversion(true, 5); + public static readonly Conversion ExplicitNullableConversion = new BuiltinConversion(false, 5); + + public static readonly Conversion ImplicitPointerConversion = new BuiltinConversion(true, 6); + public static readonly Conversion ExplicitPointerConversion = new BuiltinConversion(false, 6); + + public static readonly Conversion BoxingConversion = new BuiltinConversion(true, 7); + public static readonly Conversion UnboxingConversion = new BuiltinConversion(false, 8); + + /// + /// C# 'as' cast. + /// + public static readonly Conversion TryCast = new BuiltinConversion(false, 9); + + /// + /// C# 6 string interpolation expression implicitly being converted to or . + /// + public static readonly Conversion ImplicitInterpolatedStringConversion = new BuiltinConversion(true, 10); + + /// + /// C# 7 throw expression being converted to an arbitrary type. + /// + public static readonly Conversion ThrowExpressionConversion = new BuiltinConversion(true, 11); + + public static Conversion UserDefinedConversion(IMethod operatorMethod, bool isImplicit, Conversion conversionBeforeUserDefinedOperator, Conversion conversionAfterUserDefinedOperator, bool isLifted = false, bool isAmbiguous = false) + { + if (operatorMethod == null) + throw new ArgumentNullException(nameof(operatorMethod)); + return new UserDefinedConv(isImplicit, operatorMethod, conversionBeforeUserDefinedOperator, conversionAfterUserDefinedOperator, isLifted, isAmbiguous); + } + + public static Conversion MethodGroupConversion(IMethod chosenMethod, bool isVirtualMethodLookup, bool delegateCapturesFirstArgument) + { + if (chosenMethod == null) + throw new ArgumentNullException(nameof(chosenMethod)); + return new MethodGroupConv(chosenMethod, isVirtualMethodLookup, delegateCapturesFirstArgument, isValid: true); + } + + public static Conversion InvalidMethodGroupConversion(IMethod chosenMethod, bool isVirtualMethodLookup, bool delegateCapturesFirstArgument) + { + if (chosenMethod == null) + throw new ArgumentNullException(nameof(chosenMethod)); + return new MethodGroupConv(chosenMethod, isVirtualMethodLookup, delegateCapturesFirstArgument, isValid: false); + } + + public static Conversion TupleConversion(ImmutableArray conversions) + { + return new TupleConv(conversions); + } + #endregion + + #region Inner classes + sealed class InvalidConversion : Conversion + { + public override bool IsValid { + get { return false; } + } + + public override string ToString() + { + return "None"; + } + } + + sealed class NumericOrEnumerationConversion : Conversion + { + readonly bool isImplicit; + readonly bool isLifted; + readonly bool isEnumeration; + + public NumericOrEnumerationConversion(bool isImplicit, bool isLifted, bool isEnumeration = false) + { + this.isImplicit = isImplicit; + this.isLifted = isLifted; + this.isEnumeration = isEnumeration; + } + + public override bool IsImplicit { + get { return isImplicit; } + } + + public override bool IsExplicit { + get { return !isImplicit; } + } + + public override bool IsNumericConversion { + get { return !isEnumeration; } + } + + public override bool IsEnumerationConversion { + get { return isEnumeration; } + } + + public override bool IsLifted { + get { return isLifted; } + } + + public override string ToString() + { + return (isImplicit ? "implicit" : "explicit") + + (isLifted ? " lifted" : "") + + (isEnumeration ? " enumeration" : " numeric") + + " conversion"; + } + + public override bool Equals(Conversion other) + { + var o = other as NumericOrEnumerationConversion; + return o != null && isImplicit == o.isImplicit && isLifted == o.isLifted && isEnumeration == o.isEnumeration; + } + + public override int GetHashCode() + { + return (isImplicit ? 1 : 0) + (isLifted ? 2 : 0) + (isEnumeration ? 4 : 0); + } + } + + sealed class BuiltinConversion : Conversion + { + readonly bool isImplicit; + readonly byte type; + + public BuiltinConversion(bool isImplicit, byte type) + { + this.isImplicit = isImplicit; + this.type = type; + } + + public override bool IsImplicit { + get { return isImplicit; } + } + + public override bool IsExplicit { + get { return !isImplicit; } + } + + public override bool IsIdentityConversion { + get { return type == 0; } + } + + public override bool IsNullLiteralConversion { + get { return type == 1; } + } + + public override bool IsConstantExpressionConversion { + get { return type == 2; } + } + + public override bool IsReferenceConversion { + get { return type == 3; } + } + + public override bool IsDynamicConversion { + get { return type == 4; } + } + + public override bool IsNullableConversion { + get { return type == 5; } + } + + public override bool IsPointerConversion { + get { return type == 6; } + } + + public override bool IsBoxingConversion { + get { return type == 7; } + } + + public override bool IsUnboxingConversion { + get { return type == 8; } + } + + public override bool IsTryCast { + get { return type == 9; } + } + + public override bool IsInterpolatedStringConversion => type == 10; + + public override bool IsThrowExpressionConversion { + get { return type == 11; } + } + + public override string ToString() + { + string name = null; + switch (type) + { + case 0: + return "identity conversion"; + case 1: + return "null-literal conversion"; + case 2: + name = "constant-expression"; + break; + case 3: + name = "reference"; + break; + case 4: + name = "dynamic"; + break; + case 5: + name = "nullable"; + break; + case 6: + name = "pointer"; + break; + case 7: + return "boxing conversion"; + case 8: + return "unboxing conversion"; + case 9: + return "try cast"; + case 10: + return "interpolated string"; + case 11: + return "throw-expression conversion"; + } + return (isImplicit ? "implicit " : "explicit ") + name + " conversion"; + } + } + + sealed class UserDefinedConv : Conversion + { + readonly IMethod method; + readonly bool isLifted; + readonly Conversion conversionBeforeUserDefinedOperator; + readonly Conversion conversionAfterUserDefinedOperator; + readonly bool isImplicit; + readonly bool isValid; + + public UserDefinedConv(bool isImplicit, IMethod method, Conversion conversionBeforeUserDefinedOperator, Conversion conversionAfterUserDefinedOperator, bool isLifted, bool isAmbiguous) + { + this.method = method; + this.isLifted = isLifted; + this.conversionBeforeUserDefinedOperator = conversionBeforeUserDefinedOperator; + this.conversionAfterUserDefinedOperator = conversionAfterUserDefinedOperator; + this.isImplicit = isImplicit; + this.isValid = !isAmbiguous; + } + + public override bool IsValid { + get { return isValid; } + } + + public override bool IsImplicit { + get { return isImplicit; } + } + + public override bool IsExplicit { + get { return !isImplicit; } + } + + public override bool IsLifted { + get { return isLifted; } + } + + public override bool IsUserDefined { + get { return true; } + } + + public override Conversion ConversionBeforeUserDefinedOperator { + get { return conversionBeforeUserDefinedOperator; } + } + + public override Conversion ConversionAfterUserDefinedOperator { + get { return conversionAfterUserDefinedOperator; } + } + + public override IMethod Method { + get { return method; } + } + + public override bool Equals(Conversion other) + { + var o = other as UserDefinedConv; + return o != null && isLifted == o.isLifted && isImplicit == o.isImplicit && isValid == o.isValid && method.Equals(o.method); + } + + public override int GetHashCode() + { + return unchecked(method.GetHashCode() + (isLifted ? 31 : 27) + (isImplicit ? 71 : 61) + (isValid ? 107 : 109)); + } + + public override string ToString() + { + return (isImplicit ? "implicit" : "explicit") + + (isLifted ? " lifted" : "") + + (isValid ? "" : " ambiguous") + + "user-defined conversion (" + method + ")"; + } + } + + sealed class MethodGroupConv : Conversion + { + readonly IMethod method; + readonly bool isVirtualMethodLookup; + readonly bool delegateCapturesFirstArgument; + readonly bool isValid; + + public MethodGroupConv(IMethod method, bool isVirtualMethodLookup, bool delegateCapturesFirstArgument, bool isValid) + { + this.method = method; + this.isVirtualMethodLookup = isVirtualMethodLookup; + this.delegateCapturesFirstArgument = delegateCapturesFirstArgument; + this.isValid = isValid; + } + + public override bool IsValid { + get { return isValid; } + } + + public override bool IsImplicit { + get { return true; } + } + + public override bool IsMethodGroupConversion { + get { return true; } + } + + public override bool IsVirtualMethodLookup { + get { return isVirtualMethodLookup; } + } + + public override bool DelegateCapturesFirstArgument { + get { return delegateCapturesFirstArgument; } + } + + public override IMethod Method { + get { return method; } + } + + public override bool Equals(Conversion other) + { + var o = other as MethodGroupConv; + return o != null && method.Equals(o.method); + } + + public override int GetHashCode() + { + return method.GetHashCode(); + } + } + + sealed class TupleConv : Conversion + { + public override bool IsImplicit { get; } + public override bool IsExplicit => !IsImplicit; + public override ImmutableArray ElementConversions { get; } + public override bool IsTupleConversion => true; + + public TupleConv(ImmutableArray elementConversions) + { + this.ElementConversions = elementConversions; + this.IsImplicit = elementConversions.All(c => c.IsImplicit); + } + + public override bool Equals(Conversion other) + { + return other is TupleConv o + && ElementConversions.SequenceEqual(o.ElementConversions); + } + + public override int GetHashCode() + { + unchecked + { + var hash = 0; + foreach (var conv in ElementConversions) + { + hash *= 31; + hash += conv.GetHashCode(); + } + return hash; + } + } + + public override string ToString() + { + return (IsImplicit ? "implicit " : "explicit ") + " tuple conversion"; + } + } + #endregion + + /// + /// Gets whether the conversion is valid. + /// + public virtual bool IsValid { + get { return true; } + } + + public virtual bool IsImplicit { + get { return false; } + } + + public virtual bool IsExplicit { + get { return false; } + } + + /// + /// Gets whether the conversion is an 'as' cast. + /// + public virtual bool IsTryCast { + get { return false; } + } + + public virtual bool IsThrowExpressionConversion { + get { return false; } + } + + public virtual bool IsIdentityConversion { + get { return false; } + } + + public virtual bool IsNullLiteralConversion { + get { return false; } + } + + public virtual bool IsConstantExpressionConversion { + get { return false; } + } + + public virtual bool IsNumericConversion { + get { return false; } + } + + /// + /// Gets whether this conversion is a lifted version of another conversion. + /// + public virtual bool IsLifted { + get { return false; } + } + + /// + /// Gets whether the conversion is dynamic. + /// + public virtual bool IsDynamicConversion { + get { return false; } + } + + /// + /// Gets whether the conversion is a reference conversion. + /// + public virtual bool IsReferenceConversion { + get { return false; } + } + + /// + /// Gets whether the conversion is an enumeration conversion. + /// + public virtual bool IsEnumerationConversion { + get { return false; } + } + + /// + /// Gets whether the conversion is a nullable conversion + /// (conversion between a nullable type and the regular type). + /// + public virtual bool IsNullableConversion { + get { return false; } + } + + /// + /// Gets whether this conversion is user-defined (op_Implicit or op_Explicit). + /// + public virtual bool IsUserDefined { + get { return false; } + } + + /// + /// The conversion that is applied to the input before the user-defined conversion operator is invoked. + /// + public virtual Conversion ConversionBeforeUserDefinedOperator { + get { return null; } + } + + /// + /// The conversion that is applied to the result of the user-defined conversion operator. + /// + public virtual Conversion ConversionAfterUserDefinedOperator { + get { return null; } + } + + /// + /// Gets whether this conversion is a boxing conversion. + /// + public virtual bool IsBoxingConversion { + get { return false; } + } + + /// + /// Gets whether this conversion is an unboxing conversion. + /// + public virtual bool IsUnboxingConversion { + get { return false; } + } + + /// + /// Gets whether this conversion is a pointer conversion. + /// + public virtual bool IsPointerConversion { + get { return false; } + } + + /// + /// Gets whether this conversion is a method group conversion. + /// + public virtual bool IsMethodGroupConversion { + get { return false; } + } + + /// + /// For method-group conversions, gets whether to perform a virtual method lookup at runtime. + /// + public virtual bool IsVirtualMethodLookup { + get { return false; } + } + + /// + /// For method-group conversions, gets whether the conversion captures the first argument. + /// + /// For instance methods, this property always returns true for C# method-group conversions. + /// For static methods, this property returns true for method-group conversions of an extension method performed on an instance (eg. Func<int> f = myEnumerable.Single). + /// + public virtual bool DelegateCapturesFirstArgument { + get { return false; } + } + + /// + /// Gets whether this conversion is an anonymous function conversion. + /// + public virtual bool IsAnonymousFunctionConversion { + get { return false; } + } + + /// + /// Gets the method associated with this conversion. + /// For user-defined conversions, this is the method being called. + /// For method-group conversions, this is the method that was chosen from the group. + /// + public virtual IMethod Method { + get { return null; } + } + + /// + /// Gets whether this conversion is a tuple conversion. + /// + public virtual bool IsTupleConversion => false; + + /// + /// Gets whether this is an interpolated string conversion to or . + /// + public virtual bool IsInterpolatedStringConversion => false; + + /// + /// For a tuple conversion, gets the individual tuple element conversions. + /// + public virtual ImmutableArray ElementConversions => default(ImmutableArray); + + public override sealed bool Equals(object obj) + { + return Equals(obj as Conversion); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public virtual bool Equals(Conversion other) + { + return this == other; + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/ConversionResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/ConversionResolveResult.cs new file mode 100644 index 0000000..ad3b939 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/ConversionResolveResult.cs @@ -0,0 +1,69 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents an implicit or explicit type conversion. + /// conversionResolveResult.Input.Type is the source type; + /// conversionResolveResult.Type is the target type. + /// The property provides details about the kind of conversion. + /// + public class ConversionResolveResult : ResolveResult + { + public readonly ResolveResult Input; + public readonly Conversion Conversion; + + /// + /// For numeric conversions, specifies whether overflow checking is enabled. + /// + public readonly bool CheckForOverflow; + + public ConversionResolveResult(IType targetType, ResolveResult input, Conversion conversion) + : base(targetType) + { + if (input == null) + throw new ArgumentNullException(nameof(input)); + if (conversion == null) + throw new ArgumentNullException(nameof(conversion)); + this.Input = input; + this.Conversion = conversion; + } + + public ConversionResolveResult(IType targetType, ResolveResult input, Conversion conversion, bool checkForOverflow) + : this(targetType, input, conversion) + { + this.CheckForOverflow = checkForOverflow; + } + + public override bool IsError { + get { return !Conversion.IsValid; } + } + + public override IEnumerable GetChildResults() + { + return new[] { Input }; + } + + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/ErrorResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/ErrorResolveResult.cs new file mode 100644 index 0000000..271e62a --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/ErrorResolveResult.cs @@ -0,0 +1,56 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using ICSharpCode.Decompiler.CSharp.Syntax; +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents a resolve error. + /// + /// Note: some errors are represented by other classes; for example a may + /// be erroneous if the conversion is invalid. + /// + /// . + public class ErrorResolveResult : ResolveResult + { + /// + /// Gets an ErrorResolveResult instance with Type = SpecialType.UnknownType. + /// + public static readonly ErrorResolveResult UnknownError = new ErrorResolveResult(SpecialType.UnknownType); + + public ErrorResolveResult(IType type) : base(type) + { + } + + public ErrorResolveResult(IType type, string message, TextLocation location) : base(type) + { + this.Message = message; + this.Location = location; + } + + public override bool IsError { + get { return true; } + } + + public string Message { get; private set; } + + public TextLocation Location { get; private set; } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/ForEachResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/ForEachResolveResult.cs new file mode 100644 index 0000000..fb4edfc --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/ForEachResolveResult.cs @@ -0,0 +1,83 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Resolve result representing a 'foreach' loop. + /// + public class ForEachResolveResult : ResolveResult + { + /// + /// Gets the semantic tree for the call to GetEnumerator. + /// + public readonly ResolveResult GetEnumeratorCall; + + /// + /// Gets the collection type. + /// + public readonly IType CollectionType; + + /// + /// Gets the enumerator type. + /// + public readonly IType EnumeratorType; + + /// + /// Gets the element type. + /// This is the type that would be inferred for an implicitly-typed element variable. + /// For explicitly-typed element variables, this type may differ from ElementVariable.Type. + /// + public readonly IType ElementType; + + /// + /// Gets the Current property on the IEnumerator. + /// Returns null if the property is not found. + /// + public readonly IProperty CurrentProperty; + + /// + /// Gets the MoveNext() method on the IEnumerator. + /// Returns null if the method is not found. + /// + public readonly IMethod MoveNextMethod; + + public ForEachResolveResult(ResolveResult getEnumeratorCall, IType collectionType, IType enumeratorType, IType elementType, IProperty currentProperty, IMethod moveNextMethod, IType voidType) + : base(voidType) + { + if (getEnumeratorCall == null) + throw new ArgumentNullException(nameof(getEnumeratorCall)); + if (collectionType == null) + throw new ArgumentNullException(nameof(collectionType)); + if (enumeratorType == null) + throw new ArgumentNullException(nameof(enumeratorType)); + if (elementType == null) + throw new ArgumentNullException(nameof(elementType)); + this.GetEnumeratorCall = getEnumeratorCall; + this.CollectionType = collectionType; + this.EnumeratorType = enumeratorType; + this.ElementType = elementType; + this.CurrentProperty = currentProperty; + this.MoveNextMethod = moveNextMethod; + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/InitializedObjectResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/InitializedObjectResolveResult.cs new file mode 100644 index 0000000..8d50286 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/InitializedObjectResolveResult.cs @@ -0,0 +1,33 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Refers to the object that is currently being initialized. + /// Used within . + /// + public class InitializedObjectResolveResult : ResolveResult + { + public InitializedObjectResolveResult(IType type) : base(type) + { + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/InterpolatedStringResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/InterpolatedStringResolveResult.cs new file mode 100644 index 0000000..97d7f52 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/InterpolatedStringResolveResult.cs @@ -0,0 +1,42 @@ +// Copyright (c) 2018 Siegfried Pammer +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + public class InterpolatedStringResolveResult : ResolveResult + { + public readonly string FormatString; + public readonly ResolveResult[] Arguments; + + public InterpolatedStringResolveResult(IType stringType, string formatString, params ResolveResult[] arguments) + : base(stringType) + { + FormatString = formatString; + Arguments = arguments; + } + + public override IEnumerable GetChildResults() + { + return Arguments; + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/InvocationResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/InvocationResolveResult.cs new file mode 100644 index 0000000..1b07b65 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/InvocationResolveResult.cs @@ -0,0 +1,75 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Linq; + +using ICSharpCode.Decompiler.TypeSystem; +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents the result of a method, constructor or indexer invocation. + /// + public class InvocationResolveResult : MemberResolveResult + { + /// + /// Gets the arguments that are being passed to the method, in the order the arguments are being evaluated. + /// + public readonly IList Arguments; + + /// + /// Gets the list of initializer statements that are appplied to the result of this invocation. + /// This is used to represent object and collection initializers. + /// With the initializer statements, the is used + /// to refer to the result of this invocation. + /// + public readonly IList InitializerStatements; + + public InvocationResolveResult(ResolveResult targetResult, IParameterizedMember member, + IList arguments = null, + IList initializerStatements = null, + IType returnTypeOverride = null) + : base(targetResult, member, returnTypeOverride) + { + this.Arguments = arguments ?? EmptyList.Instance; + this.InitializerStatements = initializerStatements ?? EmptyList.Instance; + } + + public new IParameterizedMember Member { + get { return (IParameterizedMember)base.Member; } + } + + /// + /// Gets the arguments in the order they are being passed to the method. + /// For parameter arrays (params), this will return an ArrayCreateResolveResult. + /// + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", + Justification = "Derived methods may be expensive and create new lists")] + public virtual IList GetArgumentsForCall() + { + return Arguments; + } + + public override IEnumerable GetChildResults() + { + return base.GetChildResults().Concat(this.Arguments).Concat(this.InitializerStatements); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/LocalResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/LocalResolveResult.cs new file mode 100644 index 0000000..e11eaad --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/LocalResolveResult.cs @@ -0,0 +1,74 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Globalization; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents a local variable or parameter. + /// + public class LocalResolveResult : ResolveResult + { + readonly IVariable variable; + + public LocalResolveResult(IVariable variable) + : base(UnpackTypeIfByRefParameter(variable)) + { + this.variable = variable; + } + + static IType UnpackTypeIfByRefParameter(IVariable variable) + { + if (variable == null) + throw new ArgumentNullException(nameof(variable)); + var type = variable.Type; + if (type.Kind == TypeKind.ByReference) + { + var p = variable as IParameter; + if (p != null && p.ReferenceKind != ReferenceKind.None) + return ((ByReferenceType)type).ElementType; + } + return type; + } + + public IVariable Variable { + get { return variable; } + } + + public bool IsParameter { + get { return variable is IParameter; } + } + + public override bool IsCompileTimeConstant { + get { return variable.IsConst; } + } + + public override object ConstantValue { + get { return IsParameter ? null : variable.GetConstantValue(); } + } + + public override string ToString() + { + return string.Format(CultureInfo.InvariantCulture, "[LocalResolveResult {0}]", variable); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/MemberResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/MemberResolveResult.cs new file mode 100644 index 0000000..b54c96f --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/MemberResolveResult.cs @@ -0,0 +1,147 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Globalization; +using System.Linq; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents the result of a member invocation. + /// Used for field/property/event access. + /// Also, derives from MemberResolveResult. + /// + public class MemberResolveResult : ResolveResult + { + readonly IMember member; + readonly bool isConstant; + readonly object constantValue; + readonly ResolveResult targetResult; + readonly bool isVirtualCall; + + public MemberResolveResult(ResolveResult targetResult, IMember member, IType returnTypeOverride = null) + : base(returnTypeOverride ?? ComputeType(member)) + { + this.targetResult = targetResult; + this.member = member; + var thisRR = targetResult as ThisResolveResult; + this.isVirtualCall = member.IsOverridable && !(thisRR != null && thisRR.CausesNonVirtualInvocation); + + var field = member as IField; + if (field != null) + { + isConstant = field.IsConst; + if (isConstant) + constantValue = field.GetConstantValue(); + } + } + + public MemberResolveResult(ResolveResult targetResult, IMember member, bool isVirtualCall, IType returnTypeOverride = null) + : base(returnTypeOverride ?? ComputeType(member)) + { + this.targetResult = targetResult; + this.member = member; + this.isVirtualCall = isVirtualCall; + var field = member as IField; + if (field != null) + { + isConstant = field.IsConst; + if (isConstant) + constantValue = field.GetConstantValue(); + } + } + + static IType ComputeType(IMember member) + { + switch (member.SymbolKind) + { + case SymbolKind.Constructor: + return member.DeclaringType ?? SpecialType.UnknownType; + case SymbolKind.Field: + //if (((IField)member).IsFixed) + // return new PointerType(member.ReturnType); + break; + } + if (member.ReturnType.Kind == TypeKind.ByReference) + return ((ByReferenceType)member.ReturnType).ElementType; + return member.ReturnType; + } + + public MemberResolveResult(ResolveResult targetResult, IMember member, IType returnType, bool isConstant, object constantValue) + : base(returnType) + { + this.targetResult = targetResult; + this.member = member; + this.isConstant = isConstant; + this.constantValue = constantValue; + } + + public MemberResolveResult(ResolveResult targetResult, IMember member, IType returnType, bool isConstant, object constantValue, bool isVirtualCall) + : base(returnType) + { + this.targetResult = targetResult; + this.member = member; + this.isConstant = isConstant; + this.constantValue = constantValue; + this.isVirtualCall = isVirtualCall; + } + + public ResolveResult TargetResult { + get { return targetResult; } + } + + /// + /// Gets the member. + /// This property never returns null. + /// + public IMember Member { + get { return member; } + } + + /// + /// Gets whether this MemberResolveResult is a virtual call. + /// + public bool IsVirtualCall { + get { return isVirtualCall; } + } + + public override bool IsCompileTimeConstant { + get { return isConstant; } + } + + public override object ConstantValue { + get { return constantValue; } + } + + public override IEnumerable GetChildResults() + { + if (targetResult != null) + return new[] { targetResult }; + else + return Enumerable.Empty(); + } + + public override string ToString() + { + return string.Format(CultureInfo.InvariantCulture, "[{0} {1}]", GetType().Name, member); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/NamedArgumentResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/NamedArgumentResolveResult.cs new file mode 100644 index 0000000..10f6d48 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/NamedArgumentResolveResult.cs @@ -0,0 +1,82 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents a named argument. + /// + public class NamedArgumentResolveResult : ResolveResult + { + /// + /// Gets the member to which the parameter belongs. + /// This field can be null. + /// + public readonly IParameterizedMember Member; + + /// + /// Gets the parameter. + /// This field can be null. + /// + public readonly IParameter Parameter; + + /// + /// Gets the parameter name. + /// + public readonly string ParameterName; + + /// + /// Gets the argument passed to the parameter. + /// + public readonly ResolveResult Argument; + + public NamedArgumentResolveResult(IParameter parameter, ResolveResult argument, IParameterizedMember member = null) + : base(argument.Type) + { + if (parameter == null) + throw new ArgumentNullException(nameof(parameter)); + if (argument == null) + throw new ArgumentNullException(nameof(argument)); + this.Member = member; + this.Parameter = parameter; + this.ParameterName = parameter.Name; + this.Argument = argument; + } + + public NamedArgumentResolveResult(string parameterName, ResolveResult argument) + : base(argument.Type) + { + if (parameterName == null) + throw new ArgumentNullException(nameof(parameterName)); + if (argument == null) + throw new ArgumentNullException(nameof(argument)); + this.ParameterName = parameterName; + this.Argument = argument; + } + + public override IEnumerable GetChildResults() + { + return new[] { Argument }; + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/NamespaceResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/NamespaceResolveResult.cs new file mode 100644 index 0000000..f4df33c --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/NamespaceResolveResult.cs @@ -0,0 +1,50 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Globalization; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents that an expression resolved to a namespace. + /// + public class NamespaceResolveResult : ResolveResult + { + readonly INamespace ns; + + public NamespaceResolveResult(INamespace ns) : base(SpecialType.NoType) + { + this.ns = ns; + } + + public INamespace Namespace { + get { return ns; } + } + + public string NamespaceName { + get { return ns.FullName; } + } + + public override string ToString() + { + return string.Format(CultureInfo.InvariantCulture, "[{0} {1}]", GetType().Name, ns); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/OperatorResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/OperatorResolveResult.cs new file mode 100644 index 0000000..cd54d31 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/OperatorResolveResult.cs @@ -0,0 +1,91 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq.Expressions; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents a unary/binary/ternary operator invocation. + /// + public class OperatorResolveResult : ResolveResult + { + readonly ExpressionType operatorType; + readonly IMethod userDefinedOperatorMethod; + readonly IList operands; + readonly bool isLiftedOperator; + + public OperatorResolveResult(IType resultType, ExpressionType operatorType, params ResolveResult[] operands) + : base(resultType) + { + if (operands == null) + throw new ArgumentNullException(nameof(operands)); + this.operatorType = operatorType; + this.operands = operands; + } + + public OperatorResolveResult(IType resultType, ExpressionType operatorType, IMethod userDefinedOperatorMethod, bool isLiftedOperator, IList operands) + : base(resultType) + { + if (operands == null) + throw new ArgumentNullException(nameof(operands)); + this.operatorType = operatorType; + this.userDefinedOperatorMethod = userDefinedOperatorMethod; + this.isLiftedOperator = isLiftedOperator; + this.operands = operands; + } + + /// + /// Gets the operator type. + /// + public ExpressionType OperatorType { + get { return operatorType; } + } + + /// + /// Gets the operands. + /// + public IList Operands { + get { return operands; } + } + + /// + /// Gets the user defined operator method. + /// Returns null if this is a predefined operator. + /// + public IMethod UserDefinedOperatorMethod { + get { return userDefinedOperatorMethod; } + } + + /// + /// Gets whether this is a lifted operator. + /// + public bool IsLiftedOperator { + get { return isLiftedOperator; } + } + + public override IEnumerable GetChildResults() + { + return operands; + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/OutVarResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/OutVarResolveResult.cs new file mode 100644 index 0000000..214c994 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/OutVarResolveResult.cs @@ -0,0 +1,33 @@ +// Copyright (c) 2020 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents the implicitly-typed "out var". + /// Special-cased in overload resolution to be compatible with any out-parameter. + /// + class OutVarResolveResult : ResolveResult + { + public static readonly OutVarResolveResult Instance = new OutVarResolveResult(); + + public OutVarResolveResult() : base(SpecialType.NoType) { } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/ResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/ResolveResult.cs new file mode 100644 index 0000000..6ca0a17 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/ResolveResult.cs @@ -0,0 +1,74 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents the result of resolving an expression. + /// + public class ResolveResult + { + readonly IType type; + + public ResolveResult(IType type) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + this.type = type; + } + + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1721:PropertyNamesShouldNotMatchGetMethods", + Justification = "Unrelated to object.GetType()")] + public IType Type { + get { return type; } + } + + public virtual bool IsCompileTimeConstant { + get { return false; } + } + + public virtual object ConstantValue { + get { return null; } + } + + public virtual bool IsError { + get { return false; } + } + + public override string ToString() + { + return "[" + GetType().Name + " " + type + "]"; + } + + public virtual IEnumerable GetChildResults() + { + return Enumerable.Empty(); + } + + public virtual ResolveResult ShallowClone() + { + return (ResolveResult)MemberwiseClone(); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/SizeOfResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/SizeOfResolveResult.cs new file mode 100644 index 0000000..48bbdc2 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/SizeOfResolveResult.cs @@ -0,0 +1,67 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents the 'sizeof'. + /// + public class SizeOfResolveResult : ResolveResult + { + readonly IType referencedType; + readonly int? constantValue; + + public SizeOfResolveResult(IType int32, IType referencedType, int? constantValue) + : base(int32) + { + if (referencedType == null) + throw new ArgumentNullException(nameof(referencedType)); + this.referencedType = referencedType; + this.constantValue = constantValue; + } + + /// + /// The type referenced by the 'sizeof'. + /// + public IType ReferencedType { + get { return referencedType; } + } + + public override bool IsCompileTimeConstant { + get { + return constantValue != null; + } + } + + public override object ConstantValue { + get { + return constantValue; + } + } + + public override bool IsError { + get { + return referencedType.IsReferenceType != false; + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/ThisResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/ThisResolveResult.cs new file mode 100644 index 0000000..fa5f065 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/ThisResolveResult.cs @@ -0,0 +1,43 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents the 'this' reference. + /// Also used for the 'base' reference. + /// + public class ThisResolveResult : ResolveResult + { + bool causesNonVirtualInvocation; + + public ThisResolveResult(IType type, bool causesNonVirtualInvocation = false) : base(type) + { + this.causesNonVirtualInvocation = causesNonVirtualInvocation; + } + + /// + /// Gets whether this resolve result causes member invocations to be non-virtual. + /// + public bool CausesNonVirtualInvocation { + get { return causesNonVirtualInvocation; } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/ThrowResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/ThrowResolveResult.cs new file mode 100644 index 0000000..518e38e --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/ThrowResolveResult.cs @@ -0,0 +1,29 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + class ThrowResolveResult : ResolveResult + { + public ThrowResolveResult() : base(SpecialType.NoType) + { + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/TupleResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/TupleResolveResult.cs new file mode 100644 index 0000000..d099543 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/TupleResolveResult.cs @@ -0,0 +1,56 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Linq; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Resolve result for a C# 7 tuple literal. + /// + public class TupleResolveResult : ResolveResult + { + public ImmutableArray Elements { get; } + + public TupleResolveResult(ICompilation compilation, + ImmutableArray elements, + ImmutableArray elementNames = default(ImmutableArray), + IModule valueTupleAssembly = null) + : base(GetTupleType(compilation, elements, elementNames, valueTupleAssembly)) + { + this.Elements = elements; + } + + public override IEnumerable GetChildResults() + { + return Elements; + } + + static IType GetTupleType(ICompilation compilation, ImmutableArray elements, ImmutableArray elementNames, IModule valueTupleAssembly) + { + if (elements.Any(e => e.Type.Kind == TypeKind.None || e.Type.Kind == TypeKind.Null)) + return SpecialType.NoType; + else + return new TupleType(compilation, elements.Select(e => e.Type).ToImmutableArray(), elementNames, valueTupleAssembly); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/TypeIsResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/TypeIsResolveResult.cs new file mode 100644 index 0000000..5d591c2 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/TypeIsResolveResult.cs @@ -0,0 +1,48 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Resolve result for a C# 'is' expression. + /// "Input is TargetType". + /// + public class TypeIsResolveResult : ResolveResult + { + public readonly ResolveResult Input; + /// + /// Type that is being compared with. + /// + public readonly IType TargetType; + + public TypeIsResolveResult(ResolveResult input, IType targetType, IType booleanType) + : base(booleanType) + { + if (input == null) + throw new ArgumentNullException(nameof(input)); + if (targetType == null) + throw new ArgumentNullException(nameof(targetType)); + this.Input = input; + this.TargetType = targetType; + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/TypeOfResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/TypeOfResolveResult.cs new file mode 100644 index 0000000..2452bdf --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/TypeOfResolveResult.cs @@ -0,0 +1,47 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents the 'typeof'. + /// + public class TypeOfResolveResult : ResolveResult + { + readonly IType referencedType; + + public TypeOfResolveResult(IType systemType, IType referencedType) + : base(systemType) + { + if (referencedType == null) + throw new ArgumentNullException(nameof(referencedType)); + this.referencedType = referencedType; + } + + /// + /// The type referenced by the 'typeof'. + /// + public IType ReferencedType { + get { return referencedType; } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/TypeResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/TypeResolveResult.cs new file mode 100644 index 0000000..651033d --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/TypeResolveResult.cs @@ -0,0 +1,37 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// The resolved expression refers to a type name. + /// + public class TypeResolveResult : ResolveResult + { + public TypeResolveResult(IType type) + : base(type) + { + } + + public override bool IsError { + get { return this.Type.Kind == TypeKind.Unknown; } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Semantics/UnknownMemberResolveResult.cs b/src/ICSharpCode.Decompiler/Semantics/UnknownMemberResolveResult.cs new file mode 100644 index 0000000..0a4d0d3 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Semantics/UnknownMemberResolveResult.cs @@ -0,0 +1,123 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Globalization; +using System.Linq; + +using ICSharpCode.Decompiler.TypeSystem; + +namespace ICSharpCode.Decompiler.Semantics +{ + /// + /// Represents an unknown member. + /// + public class UnknownMemberResolveResult : ResolveResult + { + readonly IType targetType; + readonly string memberName; + readonly ReadOnlyCollection typeArguments; + + public UnknownMemberResolveResult(IType targetType, string memberName, IEnumerable typeArguments) + : base(SpecialType.UnknownType) + { + if (targetType == null) + throw new ArgumentNullException(nameof(targetType)); + this.targetType = targetType; + this.memberName = memberName; + this.typeArguments = new ReadOnlyCollection(typeArguments.ToArray()); + } + + /// + /// The type on which the method is being called. + /// + public IType TargetType { + get { return targetType; } + } + + public string MemberName { + get { return memberName; } + } + + public ReadOnlyCollection TypeArguments { + get { return typeArguments; } + } + + public override bool IsError { + get { return true; } + } + + public override string ToString() + { + return string.Format(CultureInfo.InvariantCulture, "[{0} {1}.{2}]", GetType().Name, targetType, memberName); + } + } + + /// + /// Represents an unknown method. + /// + public class UnknownMethodResolveResult : UnknownMemberResolveResult + { + readonly ReadOnlyCollection parameters; + + public UnknownMethodResolveResult(IType targetType, string methodName, IEnumerable typeArguments, IEnumerable parameters) + : base(targetType, methodName, typeArguments) + { + this.parameters = new ReadOnlyCollection(parameters.ToArray()); + } + + public ReadOnlyCollection Parameters { + get { return parameters; } + } + } + + /// + /// Represents an unknown identifier. + /// + public class UnknownIdentifierResolveResult : ResolveResult + { + readonly string identifier; + readonly int typeArgumentCount; + + public UnknownIdentifierResolveResult(string identifier, int typeArgumentCount = 0) + : base(SpecialType.UnknownType) + { + this.identifier = identifier; + this.typeArgumentCount = typeArgumentCount; + } + + public string Identifier { + get { return identifier; } + } + + public int TypeArgumentCount { + get { return typeArgumentCount; } + } + + public override bool IsError { + get { return true; } + } + + public override string ToString() + { + return string.Format(CultureInfo.InvariantCulture, "[{0} {1}]", GetType().Name, identifier); + } + } +} diff --git a/src/ICSharpCode.Decompiler/SingleFileBundle.cs b/src/ICSharpCode.Decompiler/SingleFileBundle.cs new file mode 100644 index 0000000..28bc2c5 --- /dev/null +++ b/src/ICSharpCode.Decompiler/SingleFileBundle.cs @@ -0,0 +1,164 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Immutable; +using System.IO; +using System.IO.MemoryMappedFiles; +using System.Runtime.CompilerServices; +using System.Text; + +namespace ICSharpCode.Decompiler +{ + /// + /// Class for dealing with .NET 5 single-file bundles. + /// + /// Based on code from Microsoft.NET.HostModel. + /// + public static class SingleFileBundle + { + /// + /// Check if the memory-mapped data is a single-file bundle + /// + public static unsafe bool IsBundle(MemoryMappedViewAccessor view, out long bundleHeaderOffset) + { + var buffer = view.SafeMemoryMappedViewHandle; + byte* ptr = null; + buffer.AcquirePointer(ref ptr); + try + { + return IsBundle(ptr, checked((long)buffer.ByteLength), out bundleHeaderOffset); + } + finally + { + buffer.ReleasePointer(); + } + } + + public static unsafe bool IsBundle(byte* data, long size, out long bundleHeaderOffset) + { + ReadOnlySpan bundleSignature = new byte[] { + // 32 bytes represent the bundle signature: SHA-256 for ".net core bundle" + 0x8b, 0x12, 0x02, 0xb9, 0x6a, 0x61, 0x20, 0x38, + 0x72, 0x7b, 0x93, 0x02, 0x14, 0xd7, 0xa0, 0x32, + 0x13, 0xf5, 0xb9, 0xe6, 0xef, 0xae, 0x33, 0x18, + 0xee, 0x3b, 0x2d, 0xce, 0x24, 0xb3, 0x6a, 0xae + }; + + var end = data + (size - bundleSignature.Length); + for (var ptr = data; ptr < end; ptr++) + { + if (*ptr == 0x8b && bundleSignature.SequenceEqual(new ReadOnlySpan(ptr, bundleSignature.Length))) + { + bundleHeaderOffset = Unsafe.ReadUnaligned(ptr - sizeof(long)); + if (bundleHeaderOffset > 0 && bundleHeaderOffset < size) + { + return true; + } + } + } + + bundleHeaderOffset = 0; + return false; + } + + public struct Header + { + public uint MajorVersion; + public uint MinorVersion; + public int FileCount; + public string BundleID; + + // Fields introduced with v2: + public long DepsJsonOffset; + public long DepsJsonSize; + public long RuntimeConfigJsonOffset; + public long RuntimeConfigJsonSize; + public ulong Flags; + + public ImmutableArray Entries; + } + + /// + /// FileType: Identifies the type of file embedded into the bundle. + /// + /// The bundler differentiates a few kinds of files via the manifest, + /// with respect to the way in which they'll be used by the runtime. + /// + public enum FileType : byte + { + Unknown, // Type not determined. + Assembly, // IL and R2R Assemblies + NativeBinary, // NativeBinaries + DepsJson, // .deps.json configuration file + RuntimeConfigJson, // .runtimeconfig.json configuration file + Symbols // PDB Files + }; + + public struct Entry + { + public long Offset; + public long Size; + public FileType Type; + public string RelativePath; // Path of an embedded file, relative to the Bundle source-directory. + } + + static UnmanagedMemoryStream AsStream(MemoryMappedViewAccessor view) + { + var size = checked((long)view.SafeMemoryMappedViewHandle.ByteLength); + return new UnmanagedMemoryStream(view.SafeMemoryMappedViewHandle, 0, size); + } + + /// + /// Reads the manifest header from the memory mapping. + /// + public static Header ReadManifest(MemoryMappedViewAccessor view, long bundleHeaderOffset) + { + using var stream = AsStream(view); + stream.Seek(bundleHeaderOffset, SeekOrigin.Begin); + return ReadManifest(stream); + } + + /// + /// Reads the manifest header from the stream. + /// + public static Header ReadManifest(Stream stream) + { + var header = new Header(); + using var reader = new BinaryReader(stream, Encoding.UTF8, leaveOpen: true); + header.MajorVersion = reader.ReadUInt32(); + header.MinorVersion = reader.ReadUInt32(); + if (header.MajorVersion < 1 || header.MajorVersion > 2) + { + throw new InvalidDataException($"Unsupported manifest version: {header.MajorVersion}.{header.MinorVersion}"); + } + header.FileCount = reader.ReadInt32(); + header.BundleID = reader.ReadString(); + if (header.MajorVersion >= 2) + { + header.DepsJsonOffset = reader.ReadInt64(); + header.DepsJsonSize = reader.ReadInt64(); + header.RuntimeConfigJsonOffset = reader.ReadInt64(); + header.RuntimeConfigJsonSize = reader.ReadInt64(); + header.Flags = reader.ReadUInt64(); + } + var entries = ImmutableArray.CreateBuilder(header.FileCount); + for (var i = 0; i < header.FileCount; i++) + { + entries.Add(ReadEntry(reader)); + } + header.Entries = entries.MoveToImmutable(); + return header; + } + + private static Entry ReadEntry(BinaryReader reader) + { + Entry entry; + entry.Offset = reader.ReadInt64(); + entry.Size = reader.ReadInt64(); + entry.Type = (FileType)reader.ReadByte(); + entry.RelativePath = reader.ReadString(); + return entry; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TextLocation.cs b/src/ICSharpCode.Decompiler/TextLocation.cs new file mode 100644 index 0000000..e35851c --- /dev/null +++ b/src/ICSharpCode.Decompiler/TextLocation.cs @@ -0,0 +1,223 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.ComponentModel; +using System.Globalization; + +namespace ICSharpCode.Decompiler.CSharp.Syntax +{ + /// + /// A line/column position. + /// Text editor lines/columns are counted started from one. + /// + [Serializable] + [TypeConverter(typeof(TextLocationConverter))] + public struct TextLocation : IComparable, IEquatable + { + /// + /// Represents no text location (0, 0). + /// + public static readonly TextLocation Empty = new TextLocation(0, 0); + + /// + /// Constant of the minimum line. + /// + public const int MinLine = 1; + + /// + /// Constant of the minimum column. + /// + public const int MinColumn = 1; + + /// + /// Creates a TextLocation instance. + /// + public TextLocation(int line, int column) + { + this.line = line; + this.column = column; + } + + int column, line; + + /// + /// Gets the line number. + /// + public int Line { + get { return line; } + } + + /// + /// Gets the column number. + /// + public int Column { + get { return column; } + } + + /// + /// Gets whether the TextLocation instance is empty. + /// + public bool IsEmpty { + get { + return column < MinLine && line < MinColumn; + } + } + + /// + /// Gets a string representation for debugging purposes. + /// + public override string ToString() + { + return string.Format(CultureInfo.InvariantCulture, "(Line {1}, Col {0})", this.column, this.line); + } + + /// + /// Gets a hash code. + /// + public override int GetHashCode() + { + return unchecked(191 * column.GetHashCode() ^ line.GetHashCode()); + } + + /// + /// Equality test. + /// + public override bool Equals(object obj) + { + if (!(obj is TextLocation)) + return false; + return (TextLocation)obj == this; + } + + /// + /// Equality test. + /// + public bool Equals(TextLocation other) + { + return this == other; + } + + /// + /// Equality test. + /// + public static bool operator ==(TextLocation left, TextLocation right) + { + return left.column == right.column && left.line == right.line; + } + + /// + /// Inequality test. + /// + public static bool operator !=(TextLocation left, TextLocation right) + { + return left.column != right.column || left.line != right.line; + } + + /// + /// Compares two text locations. + /// + public static bool operator <(TextLocation left, TextLocation right) + { + if (left.line < right.line) + return true; + else if (left.line == right.line) + return left.column < right.column; + else + return false; + } + + /// + /// Compares two text locations. + /// + public static bool operator >(TextLocation left, TextLocation right) + { + if (left.line > right.line) + return true; + else if (left.line == right.line) + return left.column > right.column; + else + return false; + } + + /// + /// Compares two text locations. + /// + public static bool operator <=(TextLocation left, TextLocation right) + { + return !(left > right); + } + + /// + /// Compares two text locations. + /// + public static bool operator >=(TextLocation left, TextLocation right) + { + return !(left < right); + } + + /// + /// Compares two text locations. + /// + public int CompareTo(TextLocation other) + { + if (this == other) + return 0; + if (this < other) + return -1; + else + return 1; + } + } + + public class TextLocationConverter : TypeConverter + { + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) + { + return sourceType == typeof(string) || base.CanConvertFrom(context, sourceType); + } + + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) + { + return destinationType == typeof(TextLocation) || base.CanConvertTo(context, destinationType); + } + + public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) + { + if (value is string) + { + var parts = ((string)value).Split(';', ','); + if (parts.Length == 2) + { + return new TextLocation(int.Parse(parts[0]), int.Parse(parts[1])); + } + } + return base.ConvertFrom(context, culture, value); + } + + public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) + { + if (value is TextLocation) + { + var loc = (TextLocation)value; + return loc.Line + ";" + loc.Column; + } + return base.ConvertTo(context, culture, value, destinationType); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Accessibility.cs b/src/ICSharpCode.Decompiler/TypeSystem/Accessibility.cs new file mode 100644 index 0000000..b60a510 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Accessibility.cs @@ -0,0 +1,142 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Diagnostics; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Enum that describes the accessibility of an entity. + /// + public enum Accessibility : byte + { + // Note: some code depends on the fact that these values are within the range 0-7 + + /// + /// The entity is completely inaccessible. This is used for C# explicit interface implementations. + /// + None, + /// + /// The entity is only accessible within the same class. + /// + Private, + /// + /// The entity is accessible in derived classes within the same assembly. + /// This corresponds to C# private protected. + /// + ProtectedAndInternal, + /// + /// The entity is only accessible within the same class and in derived classes. + /// + Protected, + /// + /// The entity is accessible within the same assembly. + /// + Internal, + /// + /// The entity is accessible both everywhere in the assembly, and in all derived classes. + /// This corresponds to C# protected internal. + /// + ProtectedOrInternal, + /// + /// The entity is accessible everywhere. + /// + Public, + } + + public static class AccessibilityExtensions + { + // This code depends on the fact that the enum values are sorted similar to the partial order + // where an accessibility is smaller than another if it makes an entity visibible to a subset of the code: + // digraph Accessibilities { + // none -> private -> protected_and_internal -> protected -> protected_or_internal -> public; + // none -> private -> protected_and_internal -> internal -> protected_or_internal -> public; + // } + + /// + /// Gets whether a <= b in the partial order of accessibilities: + /// return true if b is accessible everywhere where a is accessible. + /// + public static bool LessThanOrEqual(this Accessibility a, Accessibility b) + { + // Exploit the enum order being similar to the partial order to dramatically simplify the logic here: + // protected vs. internal is the only pair for which the enum value order doesn't match the partial order + return a <= b && !(a == Accessibility.Protected && b == Accessibility.Internal); + } + + /// + /// Computes the intersection of the two accessibilities: + /// The result is accessible from any given point in the code + /// iff both a and b are accessible from that point. + /// + public static Accessibility Intersect(this Accessibility a, Accessibility b) + { + if (a > b) + { + ExtensionMethods.Swap(ref a, ref b); + } + if (a == Accessibility.Protected && b == Accessibility.Internal) + { + return Accessibility.ProtectedAndInternal; + } + else + { + Debug.Assert(!(a == Accessibility.Internal && b == Accessibility.Protected)); + return a; + } + } + + /// + /// Computes the union of the two accessibilities: + /// The result is accessible from any given point in the code + /// iff at least one of a or b is accessible from that point. + /// + public static Accessibility Union(this Accessibility a, Accessibility b) + { + if (a > b) + { + ExtensionMethods.Swap(ref a, ref b); + } + if (a == Accessibility.Protected && b == Accessibility.Internal) + { + return Accessibility.ProtectedOrInternal; + } + else + { + Debug.Assert(!(a == Accessibility.Internal && b == Accessibility.Protected)); + return b; + } + } + + /// + /// Gets the effective accessibility of the entity. + /// For example, a public method in an internal class returns "internal". + /// + public static Accessibility EffectiveAccessibility(this IEntity entity) + { + var accessibility = entity.Accessibility; + for (var typeDef = entity.DeclaringTypeDefinition; typeDef != null; typeDef = typeDef.DeclaringTypeDefinition) + { + accessibility = Intersect(accessibility, typeDef.Accessibility); + } + return accessibility; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ApplyAttributeTypeVisitor.cs b/src/ICSharpCode.Decompiler/TypeSystem/ApplyAttributeTypeVisitor.cs new file mode 100644 index 0000000..fbdab9a --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ApplyAttributeTypeVisitor.cs @@ -0,0 +1,369 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Linq; + +using ICSharpCode.Decompiler.Util; + +using SRM = System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Introduces 'dynamic' and tuple types based on attribute values. + /// + sealed class ApplyAttributeTypeVisitor : TypeVisitor + { + public static IType ApplyAttributesToType( + IType inputType, + ICompilation compilation, + SRM.CustomAttributeHandleCollection? attributes, + SRM.MetadataReader metadata, + Nullability nullableContext, + bool typeChildrenOnly = false, + bool isSignatureReturnType = false) + { + var hasDynamicAttribute = false; + bool[] dynamicAttributeData = null; + var hasNativeIntegersAttribute = false; + bool[] nativeIntegersAttributeData = null; + string[] tupleElementNames = null; + Nullability nullability; + Nullability[] nullableAttributeData = null; + nullability = nullableContext; + if (attributes != null) + { + foreach (var attrHandle in attributes.Value) + { + var attr = metadata.GetCustomAttribute(attrHandle); + var attrType = attr.GetAttributeType(metadata); + if (attrType.IsKnownType(metadata, KnownAttribute.Dynamic)) + { + hasDynamicAttribute = true; + var ctor = attr.DecodeValue(Metadata.MetadataExtensions.minimalCorlibTypeProvider); + if (ctor.FixedArguments.Length == 1) + { + var arg = ctor.FixedArguments[0]; + if (arg.Value is ImmutableArray> values + && values.All(v => v.Value is bool)) + { + dynamicAttributeData = values.SelectArray(v => (bool)v.Value); + } + } + } + else if (attrType.IsKnownType(metadata, KnownAttribute.NativeInteger)) + { + hasNativeIntegersAttribute = true; + var ctor = attr.DecodeValue(Metadata.MetadataExtensions.minimalCorlibTypeProvider); + if (ctor.FixedArguments.Length == 1) + { + var arg = ctor.FixedArguments[0]; + if (arg.Value is ImmutableArray> values + && values.All(v => v.Value is bool)) + { + nativeIntegersAttributeData = values.SelectArray(v => (bool)v.Value); + } + } + } + else if (attrType.IsKnownType(metadata, KnownAttribute.TupleElementNames)) + { + var ctor = attr.DecodeValue(Metadata.MetadataExtensions.minimalCorlibTypeProvider); + if (ctor.FixedArguments.Length == 1) + { + var arg = ctor.FixedArguments[0]; + if (arg.Value is ImmutableArray> values + && values.All(v => v.Value is string || v.Value == null)) + { + tupleElementNames = values.SelectArray(v => (string)v.Value); + } + } + } + else if (attrType.IsKnownType(metadata, KnownAttribute.Nullable)) + { + var ctor = attr.DecodeValue(Metadata.MetadataExtensions.minimalCorlibTypeProvider); + if (ctor.FixedArguments.Length == 1) + { + var arg = ctor.FixedArguments[0]; + if (arg.Value is ImmutableArray> values + && values.All(v => v.Value is byte b && b <= 2)) + { + nullableAttributeData = values.SelectArray(v => (Nullability)(byte)v.Value); + } + else if (arg.Value is byte b && b <= 2) + { + nullability = (Nullability)b; + } + } + } + } + } + + if (hasDynamicAttribute || hasNativeIntegersAttribute || nullability != Nullability.Oblivious || nullableAttributeData != null) + { + var visitor = new ApplyAttributeTypeVisitor( + compilation, hasDynamicAttribute, dynamicAttributeData, + hasNativeIntegersAttribute, nativeIntegersAttributeData, + tupleElementNames, + nullability, nullableAttributeData + ); + if (isSignatureReturnType && hasDynamicAttribute + && inputType.SkipModifiers().Kind == TypeKind.ByReference + && attributes.Value.HasKnownAttribute(metadata, KnownAttribute.IsReadOnly)) + { + // crazy special case: `ref readonly` return takes one dynamic index more than + // a non-readonly `ref` return. + visitor.dynamicTypeIndex++; + } + if (typeChildrenOnly) + { + return inputType.VisitChildren(visitor); + } + else + { + return inputType.AcceptVisitor(visitor); + } + } + else + { + return inputType; + } + } + + readonly ICompilation compilation; + readonly bool hasDynamicAttribute; + readonly bool[] dynamicAttributeData; + readonly bool hasNativeIntegersAttribute; + readonly bool[] nativeIntegersAttributeData; + readonly string[] tupleElementNames; + readonly Nullability defaultNullability; + readonly Nullability[] nullableAttributeData; + int dynamicTypeIndex = 0; + int tupleTypeIndex = 0; + int nullabilityTypeIndex = 0; + int nativeIntTypeIndex = 0; + + private ApplyAttributeTypeVisitor(ICompilation compilation, + bool hasDynamicAttribute, bool[] dynamicAttributeData, + bool hasNativeIntegersAttribute, bool[] nativeIntegersAttributeData, + string[] tupleElementNames, + Nullability defaultNullability, Nullability[] nullableAttributeData) + { + this.compilation = compilation ?? throw new ArgumentNullException(nameof(compilation)); + this.hasDynamicAttribute = hasDynamicAttribute; + this.dynamicAttributeData = dynamicAttributeData; + this.hasNativeIntegersAttribute = hasNativeIntegersAttribute; + this.nativeIntegersAttributeData = nativeIntegersAttributeData; + this.tupleElementNames = tupleElementNames; + this.defaultNullability = defaultNullability; + this.nullableAttributeData = nullableAttributeData; + } + + public override IType VisitPointerType(PointerType type) + { + dynamicTypeIndex++; + return base.VisitPointerType(type); + } + + Nullability GetNullability() + { + if (nullabilityTypeIndex < nullableAttributeData?.Length) + return nullableAttributeData[nullabilityTypeIndex++]; + else + return defaultNullability; + } + + void ExpectDummyNullabilityForGenericValueType() + { + var n = GetNullability(); + Debug.Assert(n == Nullability.Oblivious); + } + + public override IType VisitArrayType(ArrayType type) + { + var nullability = GetNullability(); + dynamicTypeIndex++; + return base.VisitArrayType(type).ChangeNullability(nullability); + } + + public override IType VisitByReferenceType(ByReferenceType type) + { + dynamicTypeIndex++; + return base.VisitByReferenceType(type); + } + + public override IType VisitParameterizedType(ParameterizedType type) + { + var useTupleTypes = true; + if (useTupleTypes && TupleType.IsTupleCompatible(type, out var tupleCardinality)) + { + if (tupleCardinality > 1) + { + var valueTupleAssembly = type.GetDefinition()?.ParentModule; + ImmutableArray elementNames = default; + if (tupleElementNames != null && tupleTypeIndex < tupleElementNames.Length) + { + var extractedValues = new string[tupleCardinality]; + Array.Copy(tupleElementNames, tupleTypeIndex, extractedValues, 0, + Math.Min(tupleCardinality, tupleElementNames.Length - tupleTypeIndex)); + elementNames = ImmutableArray.CreateRange(extractedValues); + } + tupleTypeIndex += tupleCardinality; + ExpectDummyNullabilityForGenericValueType(); + var elementTypes = ImmutableArray.CreateBuilder(tupleCardinality); + do + { + var normalArgCount = Math.Min(type.TypeArguments.Count, TupleType.RestPosition - 1); + for (var i = 0; i < normalArgCount; i++) + { + dynamicTypeIndex++; + elementTypes.Add(type.TypeArguments[i].AcceptVisitor(this)); + } + if (type.TypeArguments.Count == TupleType.RestPosition) + { + type = type.TypeArguments.Last() as ParameterizedType; + ExpectDummyNullabilityForGenericValueType(); + dynamicTypeIndex++; + if (type != null && TupleType.IsTupleCompatible(type, out var nestedCardinality)) + { + tupleTypeIndex += nestedCardinality; + } + else + { + Debug.Fail("TRest should be another value tuple"); + type = null; + } + } + else + { + type = null; + } + } while (type != null); + Debug.Assert(elementTypes.Count == tupleCardinality); + return new TupleType( + compilation, + elementTypes.MoveToImmutable(), + elementNames, + valueTupleAssembly + ); + } + else + { + // C# doesn't have syntax for tuples of cardinality <= 1 + tupleTypeIndex += tupleCardinality; + } + } + // Visit generic type and type arguments. + // Like base implementation, except that it increments dynamicTypeIndex. + var genericType = type.GenericType.AcceptVisitor(this); + if (genericType.IsReferenceType != true && !genericType.IsKnownType(KnownTypeCode.NullableOfT)) + { + ExpectDummyNullabilityForGenericValueType(); + } + var changed = type.GenericType != genericType; + var arguments = new IType[type.TypeArguments.Count]; + for (var i = 0; i < type.TypeArguments.Count; i++) + { + dynamicTypeIndex++; + arguments[i] = type.TypeArguments[i].AcceptVisitor(this); + changed = changed || arguments[i] != type.TypeArguments[i]; + } + if (!changed) + return type; + return new ParameterizedType(genericType, arguments); + } + + public override IType VisitFunctionPointerType(FunctionPointerType type) + { + dynamicTypeIndex++; + if (type.ReturnIsRefReadOnly) + { + dynamicTypeIndex++; + } + var returnType = type.ReturnType.AcceptVisitor(this); + var changed = type.ReturnType != returnType; + var parameters = new IType[type.ParameterTypes.Length]; + for (var i = 0; i < parameters.Length; i++) + { + dynamicTypeIndex += type.ParameterReferenceKinds[i] switch + { + ReferenceKind.None => 1, + ReferenceKind.Ref => 1, + ReferenceKind.Out => 2, // in/out also count the modreq + ReferenceKind.In => 2, + _ => throw new NotSupportedException() + }; + parameters[i] = type.ParameterTypes[i].AcceptVisitor(this); + changed = changed || parameters[i] != type.ParameterTypes[i]; + } + if (!changed) + return type; + return type.WithSignature(returnType, parameters.ToImmutableArray()); + } + + public override IType VisitTypeDefinition(ITypeDefinition type) + { + IType newType = type; + var ktc = type.KnownTypeCode; + if (ktc == KnownTypeCode.Object && hasDynamicAttribute) + { + if (dynamicAttributeData == null || dynamicTypeIndex >= dynamicAttributeData.Length) + newType = SpecialType.Dynamic; + else if (dynamicAttributeData[dynamicTypeIndex]) + newType = SpecialType.Dynamic; + } + else if ((ktc == KnownTypeCode.IntPtr || ktc == KnownTypeCode.UIntPtr) && hasNativeIntegersAttribute) + { + // native integers use the same indexing logic as 'dynamic' + if (nativeIntegersAttributeData == null || nativeIntTypeIndex >= nativeIntegersAttributeData.Length) + newType = (ktc == KnownTypeCode.IntPtr ? SpecialType.NInt : SpecialType.NUInt); + else if (nativeIntegersAttributeData[nativeIntTypeIndex]) + newType = (ktc == KnownTypeCode.IntPtr ? SpecialType.NInt : SpecialType.NUInt); + nativeIntTypeIndex++; + } + if (type.IsReferenceType == true) + { + var nullability = GetNullability(); + return newType.ChangeNullability(nullability); + } + else + { + return newType; + } + } + + public override IType VisitOtherType(IType type) + { + type = base.VisitOtherType(type); + if (type.Kind == TypeKind.Unknown && type.IsReferenceType == true) + { + var nullability = GetNullability(); + type = type.ChangeNullability(nullability); + } + return type; + } + + public override IType VisitTypeParameter(ITypeParameter type) + { + var nullability = GetNullability(); + return type.ChangeNullability(nullability); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ArrayType.cs b/src/ICSharpCode.Decompiler/TypeSystem/ArrayType.cs new file mode 100644 index 0000000..28111f3 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ArrayType.cs @@ -0,0 +1,223 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +using ICSharpCode.Decompiler.TypeSystem.Implementation; +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Represents an array type. + /// + public sealed class ArrayType : TypeWithElementType, ICompilationProvider + { + readonly int dimensions; + readonly ICompilation compilation; + readonly Nullability nullability; + + public ArrayType(ICompilation compilation, IType elementType, int dimensions = 1, Nullability nullability = Nullability.Oblivious) : base(elementType) + { + if (compilation == null) + throw new ArgumentNullException(nameof(compilation)); + if (dimensions <= 0) + throw new ArgumentOutOfRangeException(nameof(dimensions), dimensions, "dimensions must be positive"); + this.compilation = compilation; + this.dimensions = dimensions; + this.nullability = nullability; + + var p = elementType as ICompilationProvider; + if (p != null && p.Compilation != compilation) + throw new InvalidOperationException("Cannot create an array type using a different compilation from the element type."); + } + + public override TypeKind Kind { + get { return TypeKind.Array; } + } + + public ICompilation Compilation { + get { return compilation; } + } + + public int Dimensions { + get { return dimensions; } + } + + public override Nullability Nullability => nullability; + + public override IType ChangeNullability(Nullability nullability) + { + if (nullability == this.nullability) + return this; + else + return new ArrayType(compilation, elementType, dimensions, nullability); + } + + public override string NameSuffix { + get { + return "[" + new string(',', dimensions - 1) + "]"; + } + } + + public override bool? IsReferenceType { + get { return true; } + } + + public override int GetHashCode() + { + return unchecked(elementType.GetHashCode() * 71681 + dimensions); + } + + public override bool Equals(IType other) + { + var a = other as ArrayType; + return a != null && elementType.Equals(a.elementType) && a.dimensions == dimensions && a.nullability == nullability; + } + + public override string ToString() + { + switch (nullability) + { + case Nullability.Nullable: + return elementType.ToString() + NameSuffix + "?"; + case Nullability.NotNullable: + return elementType.ToString() + NameSuffix + "!"; + default: + return elementType.ToString() + NameSuffix; + } + } + + public override IEnumerable DirectBaseTypes { + get { + var baseTypes = new List(); + var t = compilation.FindType(KnownTypeCode.Array); + if (t.Kind != TypeKind.Unknown) + baseTypes.Add(t); + if (dimensions == 1 && elementType.Kind != TypeKind.Pointer) + { + // single-dimensional arrays implement IList + var def = compilation.FindType(KnownTypeCode.IListOfT) as ITypeDefinition; + if (def != null) + baseTypes.Add(new ParameterizedType(def, new[] { elementType })); + // And in .NET 4.5 they also implement IReadOnlyList + def = compilation.FindType(KnownTypeCode.IReadOnlyListOfT) as ITypeDefinition; + if (def != null) + baseTypes.Add(new ParameterizedType(def, new[] { elementType })); + } + return baseTypes; + } + } + + public override IEnumerable GetMethods(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + return EmptyList.Instance; + else + return compilation.FindType(KnownTypeCode.Array).GetMethods(filter, options); + } + + public override IEnumerable GetMethods(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + return EmptyList.Instance; + else + return compilation.FindType(KnownTypeCode.Array).GetMethods(typeArguments, filter, options); + } + + public override IEnumerable GetAccessors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + return EmptyList.Instance; + else + return compilation.FindType(KnownTypeCode.Array).GetAccessors(filter, options); + } + + public override IEnumerable GetProperties(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + return EmptyList.Instance; + else + return compilation.FindType(KnownTypeCode.Array).GetProperties(filter, options); + } + + // NestedTypes, Events, Fields: System.Array doesn't have any; so we can use the AbstractType default implementation + // that simply returns an empty list + + public override IType AcceptVisitor(TypeVisitor visitor) + { + return visitor.VisitArrayType(this); + } + + public override IType VisitChildren(TypeVisitor visitor) + { + var e = elementType.AcceptVisitor(visitor); + if (e == elementType) + return this; + else + return new ArrayType(compilation, e, dimensions, nullability); + } + } + + [Serializable] + public sealed class ArrayTypeReference : ITypeReference, ISupportsInterning + { + readonly ITypeReference elementType; + readonly int dimensions; + + public ArrayTypeReference(ITypeReference elementType, int dimensions = 1) + { + if (elementType == null) + throw new ArgumentNullException(nameof(elementType)); + if (dimensions <= 0) + throw new ArgumentOutOfRangeException(nameof(dimensions), dimensions, "dimensions must be positive"); + this.elementType = elementType; + this.dimensions = dimensions; + } + + public ITypeReference ElementType { + get { return elementType; } + } + + public int Dimensions { + get { return dimensions; } + } + + public IType Resolve(ITypeResolveContext context) + { + return new ArrayType(context.Compilation, elementType.Resolve(context), dimensions); + } + + public override string ToString() + { + return elementType.ToString() + "[" + new string(',', dimensions - 1) + "]"; + } + + int ISupportsInterning.GetHashCodeForInterning() + { + return elementType.GetHashCode() ^ dimensions; + } + + bool ISupportsInterning.EqualsForInterning(ISupportsInterning other) + { + var o = other as ArrayTypeReference; + return o != null && elementType == o.elementType && dimensions == o.dimensions; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/AssemblyQualifiedTypeName.cs b/src/ICSharpCode.Decompiler/TypeSystem/AssemblyQualifiedTypeName.cs new file mode 100644 index 0000000..76a5bf9 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/AssemblyQualifiedTypeName.cs @@ -0,0 +1,80 @@ +// Copyright (c) 2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public struct AssemblyQualifiedTypeName : IEquatable + { + public readonly string AssemblyName; + public readonly FullTypeName TypeName; + + public AssemblyQualifiedTypeName(FullTypeName typeName, string assemblyName) + { + this.AssemblyName = assemblyName; + this.TypeName = typeName; + } + + public AssemblyQualifiedTypeName(ITypeDefinition typeDefinition) + { + this.AssemblyName = typeDefinition.ParentModule.AssemblyName; + this.TypeName = typeDefinition.FullTypeName; + } + + public override string ToString() + { + if (string.IsNullOrEmpty(AssemblyName)) + return TypeName.ToString(); + else + return TypeName.ToString() + ", " + AssemblyName; + } + + public override bool Equals(object obj) + { + return (obj is AssemblyQualifiedTypeName) && Equals((AssemblyQualifiedTypeName)obj); + } + + public bool Equals(AssemblyQualifiedTypeName other) + { + return this.AssemblyName == other.AssemblyName && this.TypeName == other.TypeName; + } + + public override int GetHashCode() + { + var hashCode = 0; + unchecked + { + if (AssemblyName != null) + hashCode += 1000000007 * AssemblyName.GetHashCode(); + hashCode += TypeName.GetHashCode(); + } + return hashCode; + } + + public static bool operator ==(AssemblyQualifiedTypeName lhs, AssemblyQualifiedTypeName rhs) + { + return lhs.Equals(rhs); + } + + public static bool operator !=(AssemblyQualifiedTypeName lhs, AssemblyQualifiedTypeName rhs) + { + return !lhs.Equals(rhs); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ByReferenceType.cs b/src/ICSharpCode.Decompiler/TypeSystem/ByReferenceType.cs new file mode 100644 index 0000000..04b1f1c --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ByReferenceType.cs @@ -0,0 +1,110 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public sealed class ByReferenceType : TypeWithElementType + { + public ByReferenceType(IType elementType) : base(elementType) + { + } + + public override TypeKind Kind { + get { return TypeKind.ByReference; } + } + + public override string NameSuffix { + get { + return "&"; + } + } + + public override bool? IsReferenceType { + get { return null; } + } + + public override bool IsByRefLike => true; + + public override int GetHashCode() + { + return elementType.GetHashCode() ^ 91725813; + } + + public override bool Equals(IType other) + { + var a = other as ByReferenceType; + return a != null && elementType.Equals(a.elementType); + } + + public override IType AcceptVisitor(TypeVisitor visitor) + { + return visitor.VisitByReferenceType(this); + } + + public override IType VisitChildren(TypeVisitor visitor) + { + var e = elementType.AcceptVisitor(visitor); + if (e == elementType) + return this; + else + return new ByReferenceType(e); + } + } + + [Serializable] + public sealed class ByReferenceTypeReference : ITypeReference, ISupportsInterning + { + readonly ITypeReference elementType; + + public ByReferenceTypeReference(ITypeReference elementType) + { + if (elementType == null) + throw new ArgumentNullException(nameof(elementType)); + this.elementType = elementType; + } + + public ITypeReference ElementType { + get { return elementType; } + } + + public IType Resolve(ITypeResolveContext context) + { + return new ByReferenceType(elementType.Resolve(context)); + } + + public override string ToString() + { + return elementType.ToString() + "&"; + } + + int ISupportsInterning.GetHashCodeForInterning() + { + return elementType.GetHashCode() ^ 91725814; + } + + bool ISupportsInterning.EqualsForInterning(ISupportsInterning other) + { + var brt = other as ByReferenceTypeReference; + return brt != null && this.elementType == brt.elementType; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ComHelper.cs b/src/ICSharpCode.Decompiler/TypeSystem/ComHelper.cs new file mode 100644 index 0000000..2323227 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ComHelper.cs @@ -0,0 +1,54 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Helper methods for COM. + /// + public static class ComHelper + { + /// + /// Gets whether the specified type is imported from COM. + /// + public static bool IsComImport(ITypeDefinition typeDefinition) + { + return typeDefinition != null + && typeDefinition.Kind == TypeKind.Interface + && typeDefinition.HasAttribute(KnownAttribute.ComImport, inherit: false); + } + + /// + /// Gets the CoClass of the specified COM interface. + /// + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Co", + Justification = "Consistent with CoClassAttribute")] + public static IType GetCoClass(ITypeDefinition typeDefinition) + { + if (typeDefinition == null) + return SpecialType.UnknownType; + var coClassAttribute = typeDefinition.GetAttribute(KnownAttribute.CoClass, inherit: false); + if (coClassAttribute != null && coClassAttribute.FixedArguments.Length == 1) + { + if (coClassAttribute.FixedArguments[0].Value is IType ty) + return ty; + } + return SpecialType.UnknownType; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/FullTypeName.cs b/src/ICSharpCode.Decompiler/TypeSystem/FullTypeName.cs new file mode 100644 index 0000000..01a10da --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/FullTypeName.cs @@ -0,0 +1,326 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Text; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Holds the full name of a type definition. + /// A full type name uniquely identifies a type definition within a single assembly. + /// + /// + /// A full type name can only represent type definitions, not arbitrary types. + /// It does not include any type arguments, and can not refer to array or pointer types. + /// + /// A full type name represented as reflection name has the syntax: + /// NamespaceName '.' TopLevelTypeName ['`'#] { '+' NestedTypeName ['`'#] } + /// + [Serializable] + public readonly struct FullTypeName : IEquatable + { + [Serializable] + readonly struct NestedTypeName + { + public readonly string Name; + public readonly int AdditionalTypeParameterCount; + + public NestedTypeName(string name, int additionalTypeParameterCount) + { + if (name == null) + throw new ArgumentNullException(nameof(name)); + this.Name = name; + this.AdditionalTypeParameterCount = additionalTypeParameterCount; + } + } + + readonly TopLevelTypeName topLevelType; + readonly NestedTypeName[] nestedTypes; + + FullTypeName(TopLevelTypeName topLevelTypeName, NestedTypeName[] nestedTypes) + { + this.topLevelType = topLevelTypeName; + this.nestedTypes = nestedTypes; + } + + /// + /// Constructs a FullTypeName representing the given top-level type. + /// + /// + /// FullTypeName has an implicit conversion operator from TopLevelTypeName, + /// so you can simply write: + /// FullTypeName f = new TopLevelTypeName(...); + /// + public FullTypeName(TopLevelTypeName topLevelTypeName) + { + this.topLevelType = topLevelTypeName; + this.nestedTypes = null; + } + + /// + /// Constructs a FullTypeName by parsing the given reflection name. + /// Note that FullTypeName can only represent type definition names. If the reflection name + /// might refer to a parameterized type or array etc., use + /// instead. + /// + /// + /// Expected syntax: NamespaceName '.' TopLevelTypeName ['`'#] { '+' NestedTypeName ['`'#] } + /// where # are type parameter counts + /// + public FullTypeName(string reflectionName) + { + var pos = reflectionName.IndexOf('+'); + if (pos < 0) + { + // top-level type + this.topLevelType = new TopLevelTypeName(reflectionName); + this.nestedTypes = null; + } + else + { + // nested type + var parts = reflectionName.Split('+'); + this.topLevelType = new TopLevelTypeName(parts[0]); + this.nestedTypes = new NestedTypeName[parts.Length - 1]; + for (var i = 0; i < nestedTypes.Length; i++) + { + int tpc; + var name = ReflectionHelper.SplitTypeParameterCountFromReflectionName(parts[i + 1], out tpc); + nestedTypes[i] = new NestedTypeName(name, tpc); + } + } + } + + /// + /// Gets the top-level type name. + /// + public TopLevelTypeName TopLevelTypeName { + get { return topLevelType; } + } + + /// + /// Gets whether this is a nested type. + /// + public bool IsNested { + get { + return nestedTypes != null; + } + } + + /// + /// Gets the nesting level. + /// + public int NestingLevel { + get { + return nestedTypes != null ? nestedTypes.Length : 0; + } + } + + /// + /// Gets the name of the type. + /// For nested types, this is the name of the innermost type. + /// + public string Name { + get { + if (nestedTypes != null) + return nestedTypes[nestedTypes.Length - 1].Name; + else + return topLevelType.Name; + } + } + + public string ReflectionName { + get { + if (nestedTypes == null) + return topLevelType.ReflectionName; + var b = new StringBuilder(topLevelType.ReflectionName); + foreach (var nt in nestedTypes) + { + b.Append('+'); + b.Append(nt.Name); + if (nt.AdditionalTypeParameterCount > 0) + { + b.Append('`'); + b.Append(nt.AdditionalTypeParameterCount); + } + } + return b.ToString(); + } + } + + /// + /// Gets the total type parameter count. + /// + public int TypeParameterCount { + get { + var tpc = topLevelType.TypeParameterCount; + if (nestedTypes != null) + { + foreach (var nt in nestedTypes) + { + tpc += nt.AdditionalTypeParameterCount; + } + } + return tpc; + } + } + + /// + /// Gets the name of the nested type at the given level. + /// + public string GetNestedTypeName(int nestingLevel) + { + if (nestedTypes == null) + throw new InvalidOperationException(); + return nestedTypes[nestingLevel].Name; + } + + /// + /// Gets the number of additional type parameters of the nested type at the given level. + /// + public int GetNestedTypeAdditionalTypeParameterCount(int nestingLevel) + { + if (nestedTypes == null) + throw new InvalidOperationException(); + return nestedTypes[nestingLevel].AdditionalTypeParameterCount; + } + + /// + /// Gets the declaring type name. + /// + /// This is a top-level type name. + /// new FullTypeName("NS.A+B+C").GetDeclaringType() will return new FullTypeName("NS.A+B") + public FullTypeName GetDeclaringType() + { + if (nestedTypes == null) + throw new InvalidOperationException(); + if (nestedTypes.Length == 1) + return topLevelType; + var outerNestedTypeNames = new NestedTypeName[nestedTypes.Length - 1]; + Array.Copy(nestedTypes, 0, outerNestedTypeNames, 0, outerNestedTypeNames.Length); + return new FullTypeName(topLevelType, outerNestedTypeNames); + } + + /// + /// Creates a nested type name. + /// + /// new FullTypeName("NS.A+B").NestedType("C", 1) will return new FullTypeName("NS.A+B+C`1") + public FullTypeName NestedType(string name, int additionalTypeParameterCount) + { + if (name == null) + throw new ArgumentNullException(nameof(name)); + var newNestedType = new NestedTypeName(name, additionalTypeParameterCount); + if (nestedTypes == null) + return new FullTypeName(topLevelType, new[] { newNestedType }); + var newNestedTypeNames = new NestedTypeName[nestedTypes.Length + 1]; + nestedTypes.CopyTo(newNestedTypeNames, 0); + newNestedTypeNames[newNestedTypeNames.Length - 1] = newNestedType; + return new FullTypeName(topLevelType, newNestedTypeNames); + } + + public static implicit operator FullTypeName(TopLevelTypeName topLevelTypeName) + { + return new FullTypeName(topLevelTypeName); + } + + public override string ToString() + { + return this.ReflectionName; + } + + #region Equals and GetHashCode implementation + public override bool Equals(object obj) + { + return obj is FullTypeName && Equals((FullTypeName)obj); + } + + public bool Equals(FullTypeName other) + { + return FullTypeNameComparer.Ordinal.Equals(this, other); + } + + public override int GetHashCode() + { + return FullTypeNameComparer.Ordinal.GetHashCode(this); + } + + public static bool operator ==(FullTypeName left, FullTypeName right) + { + return left.Equals(right); + } + + public static bool operator !=(FullTypeName left, FullTypeName right) + { + return !left.Equals(right); + } + #endregion + } + + [Serializable] + public sealed class FullTypeNameComparer : IEqualityComparer + { + public static readonly FullTypeNameComparer Ordinal = new FullTypeNameComparer(StringComparer.Ordinal); + public static readonly FullTypeNameComparer OrdinalIgnoreCase = new FullTypeNameComparer(StringComparer.OrdinalIgnoreCase); + + public readonly StringComparer NameComparer; + + public FullTypeNameComparer(StringComparer nameComparer) + { + this.NameComparer = nameComparer; + } + + public bool Equals(FullTypeName x, FullTypeName y) + { + if (x.NestingLevel != y.NestingLevel) + return false; + var topX = x.TopLevelTypeName; + var topY = y.TopLevelTypeName; + if (topX.TypeParameterCount == topY.TypeParameterCount + && NameComparer.Equals(topX.Name, topY.Name) + && NameComparer.Equals(topX.Namespace, topY.Namespace)) + { + for (var i = 0; i < x.NestingLevel; i++) + { + if (x.GetNestedTypeAdditionalTypeParameterCount(i) != y.GetNestedTypeAdditionalTypeParameterCount(i)) + return false; + if (!NameComparer.Equals(x.GetNestedTypeName(i), y.GetNestedTypeName(i))) + return false; + } + return true; + } + return false; + } + + public int GetHashCode(FullTypeName obj) + { + var top = obj.TopLevelTypeName; + var hash = NameComparer.GetHashCode(top.Name) ^ NameComparer.GetHashCode(top.Namespace) ^ top.TypeParameterCount; + unchecked + { + for (var i = 0; i < obj.NestingLevel; i++) + { + hash *= 31; + hash += NameComparer.GetHashCode(obj.Name) ^ obj.TypeParameterCount; + } + } + return hash; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/FunctionPointerType.cs b/src/ICSharpCode.Decompiler/TypeSystem/FunctionPointerType.cs new file mode 100644 index 0000000..cc43cf7 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/FunctionPointerType.cs @@ -0,0 +1,190 @@ +// Copyright (c) 2020 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Linq; +using System.Reflection.Metadata; + +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public class FunctionPointerType : AbstractType + { + public static FunctionPointerType FromSignature(MethodSignature signature, MetadataModule module) + { + var returnType = signature.ReturnType; + var returnIsRefReadOnly = false; + var customCallConvs = ImmutableArray.CreateBuilder(); + while (returnType is ModifiedType modReturn) + { + if (modReturn.Modifier.IsKnownType(KnownAttribute.In)) + { + returnType = modReturn.ElementType; + returnIsRefReadOnly = true; + } + else if (modReturn.Modifier.Name.StartsWith("CallConv", StringComparison.Ordinal) + && modReturn.Modifier.Namespace == "System.Runtime.CompilerServices") + { + returnType = modReturn.ElementType; + customCallConvs.Add(modReturn.Modifier); + } + else + { + break; + } + } + var parameterTypes = ImmutableArray.CreateBuilder(signature.ParameterTypes.Length); + var parameterReferenceKinds = ImmutableArray.CreateBuilder(signature.ParameterTypes.Length); + foreach (var p in signature.ParameterTypes) + { + var paramType = p; + var kind = ReferenceKind.None; + if (p is ModifiedType modreq) + { + if (modreq.Modifier.IsKnownType(KnownAttribute.In)) + { + kind = ReferenceKind.In; + paramType = modreq.ElementType; + } + else if (modreq.Modifier.IsKnownType(KnownAttribute.Out)) + { + kind = ReferenceKind.Out; + paramType = modreq.ElementType; + } + } + if (paramType.Kind == TypeKind.ByReference) + { + if (kind == ReferenceKind.None) + kind = ReferenceKind.Ref; + } + else + { + kind = ReferenceKind.None; + } + parameterTypes.Add(paramType); + parameterReferenceKinds.Add(kind); + } + return new FunctionPointerType( + module, signature.Header.CallingConvention, customCallConvs.ToImmutable(), + returnType, returnIsRefReadOnly, + parameterTypes.MoveToImmutable(), parameterReferenceKinds.MoveToImmutable()); + } + + private readonly MetadataModule module; + public readonly SignatureCallingConvention CallingConvention; + public readonly ImmutableArray CustomCallingConventions; + public readonly IType ReturnType; + public readonly bool ReturnIsRefReadOnly; + public readonly ImmutableArray ParameterTypes; + public readonly ImmutableArray ParameterReferenceKinds; + + public FunctionPointerType(MetadataModule module, + SignatureCallingConvention callingConvention, ImmutableArray customCallingConventions, + IType returnType, bool returnIsRefReadOnly, + ImmutableArray parameterTypes, ImmutableArray parameterReferenceKinds) + { + this.module = module; + this.CallingConvention = callingConvention; + this.CustomCallingConventions = customCallingConventions; + this.ReturnType = returnType; + this.ReturnIsRefReadOnly = returnIsRefReadOnly; + this.ParameterTypes = parameterTypes; + this.ParameterReferenceKinds = parameterReferenceKinds; + Debug.Assert(parameterTypes.Length == parameterReferenceKinds.Length); + } + + public override string Name => "delegate*"; + + public override bool? IsReferenceType => false; + + public override TypeKind Kind => TypeKind.FunctionPointer; + + public override ITypeDefinition GetDefinition() + { + return null; + } + + public override IType AcceptVisitor(TypeVisitor visitor) + { + return visitor.VisitFunctionPointerType(this); + } + + public override IType VisitChildren(TypeVisitor visitor) + { + var r = ReturnType.AcceptVisitor(visitor); + // Keep ta == null as long as no elements changed, allocate the array only if necessary. + var pt = (r != ReturnType) ? new IType[ParameterTypes.Length] : null; + for (var i = 0; i < ParameterTypes.Length; i++) + { + var p = ParameterTypes[i].AcceptVisitor(visitor); + if (p == null) + throw new NullReferenceException("TypeVisitor.Visit-method returned null"); + if (pt == null && p != ParameterTypes[i]) + { + // we found a difference, so we need to allocate the array + pt = new IType[ParameterTypes.Length]; + for (var j = 0; j < i; j++) + { + pt[j] = ParameterTypes[j]; + } + } + if (pt != null) + pt[i] = p; + } + if (pt == null) + return this; + else + return new FunctionPointerType( + module, CallingConvention, CustomCallingConventions, + r, ReturnIsRefReadOnly, + pt != null ? pt.ToImmutableArray() : ParameterTypes, + ParameterReferenceKinds); + } + + public override bool Equals(IType other) + { + return other is FunctionPointerType fpt + && CallingConvention == fpt.CallingConvention + && CustomCallingConventions.SequenceEqual(fpt.CustomCallingConventions) + && ReturnType.Equals(fpt.ReturnType) + && ReturnIsRefReadOnly == fpt.ReturnIsRefReadOnly + && ParameterTypes.SequenceEqual(fpt.ParameterTypes) + && ParameterReferenceKinds.SequenceEqual(fpt.ParameterReferenceKinds); + } + + public override int GetHashCode() + { + unchecked + { + var hash = ReturnType.GetHashCode() ^ CallingConvention.GetHashCode(); + return hash; + } + } + + internal IType WithSignature(IType returnType, ImmutableArray parameterTypes) + { + return new FunctionPointerType(this.module, + this.CallingConvention, this.CustomCallingConventions, + returnType, this.ReturnIsRefReadOnly, + parameterTypes, this.ParameterReferenceKinds); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/GenericContext.cs b/src/ICSharpCode.Decompiler/TypeSystem/GenericContext.cs new file mode 100644 index 0000000..18d696e --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/GenericContext.cs @@ -0,0 +1,88 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; + +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public readonly struct GenericContext + { + public readonly IReadOnlyList ClassTypeParameters; + public readonly IReadOnlyList MethodTypeParameters; + + public GenericContext(IReadOnlyList classTypeParameters) + { + this.ClassTypeParameters = classTypeParameters; + this.MethodTypeParameters = null; + } + + public GenericContext(IReadOnlyList classTypeParameters, IReadOnlyList methodTypeParameters) + { + this.ClassTypeParameters = classTypeParameters; + this.MethodTypeParameters = methodTypeParameters; + } + + internal GenericContext(ITypeResolveContext context) + { + this.ClassTypeParameters = context.CurrentTypeDefinition?.TypeParameters; + this.MethodTypeParameters = (context.CurrentMember as IMethod)?.TypeParameters; + } + + internal GenericContext(IEntity context) + { + if (context is ITypeDefinition td) + { + this.ClassTypeParameters = td.TypeParameters; + this.MethodTypeParameters = null; + } + else + { + this.ClassTypeParameters = context.DeclaringTypeDefinition?.TypeParameters; + this.MethodTypeParameters = (context as IMethod)?.TypeParameters; + } + } + + public ITypeParameter GetClassTypeParameter(int index) + { + if (index < ClassTypeParameters?.Count) + return ClassTypeParameters[index]; + else + return DummyTypeParameter.GetClassTypeParameter(index); + } + + public ITypeParameter GetMethodTypeParameter(int index) + { + if (index < MethodTypeParameters?.Count) + return MethodTypeParameters[index]; + else + return DummyTypeParameter.GetMethodTypeParameter(index); + } + + internal TypeParameterSubstitution ToSubstitution() + { + // The TS prefers 'null' over empty lists in substitutions, and we need our substitution + // to compare equal to the ones created by the TS. + return new TypeParameterSubstitution( + classTypeArguments: ClassTypeParameters?.Count > 0 ? ClassTypeParameters : null, + methodTypeArguments: MethodTypeParameters?.Count > 0 ? MethodTypeParameters : null + ); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IAssembly.cs b/src/ICSharpCode.Decompiler/TypeSystem/IAssembly.cs new file mode 100644 index 0000000..d2191da --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IAssembly.cs @@ -0,0 +1,112 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; + +using ICSharpCode.Decompiler.Metadata; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Interface used to help with construction of the type system. + /// + /// + /// The type system is an immutable cyclic data structure: + /// the compilation (ICompilation) has references to all modules, + /// and each module has a reference back to the compilation. + /// + /// Module references are used to solve this cyclic dependency: + /// The compilation constructor accepts module references, + /// and only the IModuleReference.Resolve() function can observe a + /// partially-constructed compilation; but not any user code. + /// + public interface IModuleReference + { + /// + /// Resolves this metadata module. + /// + IModule Resolve(ITypeResolveContext context); + } + + /// + /// Represents a metadata module. + /// + public interface IModule : ISymbol, ICompilationProvider + { + /// + /// Gets the underlying metadata file. May return null, if the IAssembly was not created from a PE file. + /// + PEFile PEFile { get; } + + /// + /// Gets whether this assembly is the main assembly of the compilation. + /// + bool IsMainModule { get; } + + /// + /// Gets the assembly name (short name). + /// + string AssemblyName { get; } + + /// + /// Gets the full assembly name (including public key token etc.) + /// + string FullAssemblyName { get; } + + /// + /// Gets the list of all assembly attributes in the project. + /// + IEnumerable GetAssemblyAttributes(); + + /// + /// Gets the list of all module attributes in the project. + /// + IEnumerable GetModuleAttributes(); + + /// + /// Gets whether the internals of this assembly are visible in the specified assembly. + /// + bool InternalsVisibleTo(IModule module); + + /// + /// Gets the root namespace for this module. + /// + /// + /// This always is the namespace without a name - it's unrelated to the 'root namespace' project setting. + /// It contains only subnamespaces and types defined in this module -- use ICompilation.RootNamespace + /// to get the combined view of all referenced assemblies. + /// + INamespace RootNamespace { get; } + + /// + /// Gets the type definition for a top-level type. + /// + /// This method uses ordinal name comparison, not the compilation's name comparer. + ITypeDefinition GetTypeDefinition(TopLevelTypeName topLevelTypeName); + + /// + /// Gets all non-nested types in the assembly. + /// + IEnumerable TopLevelTypeDefinitions { get; } + + /// + /// Gets all types in the assembly, including nested types. + /// + IEnumerable TypeDefinitions { get; } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IAttribute.cs b/src/ICSharpCode.Decompiler/TypeSystem/IAttribute.cs new file mode 100644 index 0000000..69560f1 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IAttribute.cs @@ -0,0 +1,56 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Immutable; +using System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Represents an attribute. + /// + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711:IdentifiersShouldNotHaveIncorrectSuffix")] + public interface IAttribute + { + /// + /// Gets the type of the attribute. + /// + IType AttributeType { get; } + + /// + /// Gets the constructor being used. + /// This property may return null if no matching constructor was found. + /// + IMethod Constructor { get; } + + /// + /// Gets whether there were errors decoding the attribute. + /// + bool HasDecodeErrors { get; } + + /// + /// Gets the positional arguments. + /// + ImmutableArray> FixedArguments { get; } + + /// + /// Gets the named arguments passed to the attribute. + /// + ImmutableArray> NamedArguments { get; } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ICodeContext.cs b/src/ICSharpCode.Decompiler/TypeSystem/ICodeContext.cs new file mode 100644 index 0000000..6d9525c --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ICodeContext.cs @@ -0,0 +1,37 @@ +// Copyright (c) 2014 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public interface ICodeContext : ITypeResolveContext + { + /// + /// Gets all currently visible local variables and lambda parameters. + /// Does not include method parameters. + /// + IEnumerable LocalVariables { get; } + + /// + /// Gets whether the context is within a lambda expression or anonymous method. + /// + bool IsWithinLambdaExpression { get; } + } +} + diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ICompilation.cs b/src/ICSharpCode.Decompiler/TypeSystem/ICompilation.cs new file mode 100644 index 0000000..d41f350 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ICompilation.cs @@ -0,0 +1,87 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public interface ICompilation + { + /// + /// Gets the primary module. + /// This is the module being (de)compiled; all other modules in the compilation are the other assemblies/modules + /// referenced by the main module. + /// + IModule MainModule { get; } + + /// + /// Gets the list of all modules in the compilation. + /// + /// + /// This main module is the first entry in the list. + /// + IReadOnlyList Modules { get; } + + /// + /// Gets the referenced modules. + /// This list does not include the main module. + /// + IReadOnlyList ReferencedModules { get; } + + /// + /// Gets the root namespace of this compilation. + /// This is a merged version of the root namespaces of all assemblies. + /// + /// + /// This always is the namespace without a name - it's unrelated to the 'root namespace' project setting. + /// + INamespace RootNamespace { get; } + + /// + /// Gets the root namespace for a given extern alias. + /// + /// + /// If is null or an empty string, this method + /// returns the global root namespace. + /// If no alias with the specified name exists, this method returns null. + /// + INamespace GetNamespaceForExternAlias(string alias); + + IType FindType(KnownTypeCode typeCode); + + /// + /// Gets the name comparer for the language being compiled. + /// This is the string comparer used for the INamespace.GetTypeDefinition method. + /// + StringComparer NameComparer { get; } + + CacheManager CacheManager { get; } + } + + public interface ICompilationProvider + { + /// + /// Gets the parent compilation. + /// This property never returns null. + /// + ICompilation Compilation { get; } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IDecompilerTypeSystem.cs b/src/ICSharpCode.Decompiler/TypeSystem/IDecompilerTypeSystem.cs new file mode 100644 index 0000000..a6773cd --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IDecompilerTypeSystem.cs @@ -0,0 +1,30 @@ +// Copyright (c) 2014 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Main interface for the decompiler type system. + /// + /// The MetadataModule class allows decoding/resolving metadata tokens into type system entities. + /// + public interface IDecompilerTypeSystem : ICompilation + { + new MetadataModule MainModule { get; } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IEntity.cs b/src/ICSharpCode.Decompiler/TypeSystem/IEntity.cs new file mode 100644 index 0000000..0548f27 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IEntity.cs @@ -0,0 +1,91 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Represents a resolved entity. + /// + public interface IEntity : ISymbol, ICompilationProvider, INamedElement + { + /// + /// Gets the metadata token for this entity. + /// + /// + /// The token is only valid within the context of the assembly defining this entity. + /// Token may be 0 if this is a generated member. + /// Note: specialized members will return the token of the member definition. + /// + System.Reflection.Metadata.EntityHandle MetadataToken { get; } + + /// + /// Gets the short name of the entity. + /// + new string Name { get; } + + /// + /// Gets the declaring class. + /// For members, this is the class that contains the member. + /// For nested classes, this is the outer class. For top-level entities, this property returns null. + /// + ITypeDefinition DeclaringTypeDefinition { get; } + + /// + /// Gets/Sets the declaring type (incl. type arguments, if any). + /// This property will return null for top-level entities. + /// If this is not a specialized member, the value returned is equal to . + /// + IType DeclaringType { get; } + + /// + /// The module in which this entity is defined. + /// + IModule ParentModule { get; } + + /// + /// Gets the attributes on this entity. + /// Does not include inherited attributes. + /// + IEnumerable GetAttributes(); + + /// + /// Gets the accessibility of this entity. + /// + Accessibility Accessibility { get; } + + /// + /// Gets whether this entity is static. + /// Returns true if either the 'static' or the 'const' modifier is set. + /// + bool IsStatic { get; } + + /// + /// Returns whether this entity is abstract. + /// + /// Static classes also count as abstract classes. + bool IsAbstract { get; } + + /// + /// Returns whether this entity is sealed. + /// + /// Static classes also count as sealed classes. + bool IsSealed { get; } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IEvent.cs b/src/ICSharpCode.Decompiler/TypeSystem/IEvent.cs new file mode 100644 index 0000000..ee9aa2b --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IEvent.cs @@ -0,0 +1,31 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public interface IEvent : IMember + { + bool CanAdd { get; } + bool CanRemove { get; } + bool CanInvoke { get; } + + IMethod AddAccessor { get; } + IMethod RemoveAccessor { get; } + IMethod InvokeAccessor { get; } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IField.cs b/src/ICSharpCode.Decompiler/TypeSystem/IField.cs new file mode 100644 index 0000000..18f5a00 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IField.cs @@ -0,0 +1,41 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Represents a field or constant. + /// + public interface IField : IMember, IVariable + { + /// + /// Gets the name of the field. + /// + new string Name { get; } // solve ambiguity between IMember.Name and IVariable.Name + + /// + /// Gets whether this field is readonly. + /// + bool IsReadOnly { get; } + + /// + /// Gets whether this field is volatile. + /// + bool IsVolatile { get; } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IFreezable.cs b/src/ICSharpCode.Decompiler/TypeSystem/IFreezable.cs new file mode 100644 index 0000000..b6dae14 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IFreezable.cs @@ -0,0 +1,33 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public interface IFreezable + { + /// + /// Gets if this instance is frozen. Frozen instances are immutable and thus thread-safe. + /// + bool IsFrozen { get; } + + /// + /// Freezes this instance. + /// + void Freeze(); + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IInterningProvider.cs b/src/ICSharpCode.Decompiler/TypeSystem/IInterningProvider.cs new file mode 100644 index 0000000..0c670f2 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IInterningProvider.cs @@ -0,0 +1,101 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Provider used for interning. + /// + /// + /// A simple IInterningProvider implementation could use 3 dictionaries: + /// 1. using value equality comparer (for certain types known to implement value equality, e.g. string and IType) + /// 2. using comparer that calls into ISupportsInterning (for types implementing ISupportsInterning) + /// 3. list comparer (for InternList method) + /// + /// On the first Intern()-call, the provider tells the object to prepare for interning (ISupportsInterning.PrepareForInterning) + /// and stores it into a dictionary. On further Intern() calls, the original object is returned for all equal objects. + /// This allows reducing the memory usage by using a single object instance where possible. + /// + /// Interning provider implementations could also use the interning logic for different purposes: + /// for example, it could be used to determine which objects are used jointly between multiple type definitions + /// and which are used only within a single type definition. Then a persistent file format could be organized so + /// that shared objects are loaded only once, yet non-shared objects get loaded lazily together with the class. + /// + public abstract class InterningProvider + { + public static readonly InterningProvider Dummy = new DummyInterningProvider(); + + /// + /// Interns the specified object. + /// + /// If the object is freezable, it will be frozen. + /// + public abstract ISupportsInterning Intern(ISupportsInterning obj); + + /// + /// Interns the specified object. + /// + /// If the object is freezable, it will be frozen. + /// + public T Intern(T obj) where T : class, ISupportsInterning + { + ISupportsInterning input = obj; + return (T)Intern(input); + } + + /// + /// Interns the specified string. + /// + public abstract string Intern(string text); + + /// + /// Inters a boxed value type. + /// + public abstract object InternValue(object obj); + + /// + /// Interns the given list. Uses reference equality to compare the list elements. + /// + public abstract IList InternList(IList list) where T : class; + + sealed class DummyInterningProvider : InterningProvider + { + public override ISupportsInterning Intern(ISupportsInterning obj) + { + return obj; + } + + public override string Intern(string text) + { + return text; + } + + public override object InternValue(object obj) + { + return obj; + } + + public override IList InternList(IList list) + { + return list; + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IMember.cs b/src/ICSharpCode.Decompiler/TypeSystem/IMember.cs new file mode 100644 index 0000000..bdff95f --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IMember.cs @@ -0,0 +1,123 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public interface IMemberReference + { + /// + /// Gets the declaring type reference for the member. + /// + ITypeReference DeclaringTypeReference { get; } + + /// + /// Resolves the member. + /// + /// + /// Context to use for resolving this member reference. + /// Which kind of context is required depends on the which kind of member reference this is; + /// please consult the documentation of the method that was used to create this member reference, + /// or that of the class implementing this method. + /// + /// + /// Returns the resolved member, or null if the member could not be found. + /// + IMember Resolve(ITypeResolveContext context); + } + + /// + /// Method/field/property/event. + /// + public interface IMember : IEntity + { + /// + /// Gets the original member definition for this member. + /// Returns this if this is not a specialized member. + /// Specialized members are the result of overload resolution with type substitution. + /// + IMember MemberDefinition { get; } + + /// + /// Gets the return type of this member. + /// This property never returns null. + /// + IType ReturnType { get; } + + /// + /// Gets the interface members explicitly implemented by this member. + /// + /// + /// For methods, equivalent to ( + /// from impl in DeclaringTypeDefinition.GetExplicitInterfaceImplementations() + /// where impl.Implementation == this + /// select impl.InterfaceMethod + /// ), + /// but may be more efficient than searching the whole list. + /// + /// Note that it is possible for a class to implement an interface using members in a + /// base class unrelated to that interface: + /// class BaseClass { public void Dispose() {} } + /// class C : BaseClass, IDisposable { } + /// In this case, the interface member will not show up in (BaseClass.Dispose).ImplementedInterfaceMembers, + /// so use (C).GetInterfaceImplementations() instead to handle this case. + /// + IEnumerable ExplicitlyImplementedInterfaceMembers { get; } + + /// + /// Gets whether this member is explicitly implementing an interface. + /// + bool IsExplicitInterfaceImplementation { get; } + + /// + /// Gets if the member is virtual. Is true only if the "virtual" modifier was used, but non-virtual + /// members can be overridden, too; if they are abstract or overriding a method. + /// + bool IsVirtual { get; } + + /// + /// Gets whether this member is overriding another member. + /// + bool IsOverride { get; } + + /// + /// Gets if the member can be overridden. Returns true when the member is "abstract", "virtual" or "override" but not "sealed". + /// + bool IsOverridable { get; } + + /// + /// Gets the substitution belonging to this specialized member. + /// Returns TypeParameterSubstitution.Identity for not specialized members. + /// + TypeParameterSubstitution Substitution { + get; + } + + /// + /// Specializes this member with the given substitution. + /// If this member is already specialized, the new substitution is composed with the existing substition. + /// + IMember Specialize(TypeParameterSubstitution substitution); + + /// + /// Gets whether the members are considered equal when applying the specified type normalization. + /// + bool Equals(IMember obj, TypeVisitor typeNormalization); + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IMethod.cs b/src/ICSharpCode.Decompiler/TypeSystem/IMethod.cs new file mode 100644 index 0000000..b7705b2 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IMethod.cs @@ -0,0 +1,108 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Reflection; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Represents a method, constructor, destructor or operator. + /// + public interface IMethod : IParameterizedMember + { + /// + /// Gets the attributes associated with the return type. (e.g. [return: MarshalAs(...)]) + /// + /// + /// Does not include inherited attributes. + /// + IEnumerable GetReturnTypeAttributes(); + + /// + /// Gets whether the return type is 'ref readonly'. + /// + bool ReturnTypeIsRefReadOnly { get; } + + /// + /// Gets whether this method may only be called on fresh instances. + /// Used with C# 9 `init;` property setters. + /// + bool IsInitOnly { get; } + + /// + /// Gets whether the method accepts the 'this' reference as ref readonly. + /// This can be either because the method is C# 8.0 'readonly', or because it is within a C# 7.2 'readonly struct' + /// + bool ThisIsRefReadOnly { get; } + + /// + /// Gets the type parameters of this method; or an empty list if the method is not generic. + /// + IReadOnlyList TypeParameters { get; } + + /// + /// Gets the type arguments passed to this method. + /// If the method is generic but not parameterized yet, this property returns the type parameters, + /// as if the method was parameterized with its own type arguments (void M<T>() { M<T>(); }). + /// + IReadOnlyList TypeArguments { get; } + + bool IsExtensionMethod { get; } + bool IsLocalFunction { get; } + bool IsConstructor { get; } + bool IsDestructor { get; } + bool IsOperator { get; } + + /// + /// Gets whether the method has a body. + /// This property returns false for abstract or extern methods, + /// or for partial methods without implementation. + /// + bool HasBody { get; } + + /// + /// Gets whether the method is a property/event accessor. + /// + bool IsAccessor { get; } + + /// + /// If this method is an accessor, returns the corresponding property/event. + /// Otherwise, returns null. + /// + IMember AccessorOwner { get; } + + /// + /// Gets the kind of accessor this is. + /// + MethodSemanticsAttributes AccessorKind { get; } + + /// + /// If this method is reduced from an extension method or a local function returns the original method, null otherwise. + /// A reduced method doesn't contain the extension method parameter. That means that it has one parameter less than its definition. + /// A local function doesn't contain compiler-generated method parameters at the end. + /// + IMethod ReducedFrom { get; } + + /// + /// Specializes this method with the given substitution. + /// If this method is already specialized, the new substitution is composed with the existing substition. + /// + new IMethod Specialize(TypeParameterSubstitution substitution); + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/INamedElement.cs b/src/ICSharpCode.Decompiler/TypeSystem/INamedElement.cs new file mode 100644 index 0000000..80d4528 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/INamedElement.cs @@ -0,0 +1,63 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public interface INamedElement + { + /// + /// Gets the fully qualified name of the class the return type is pointing to. + /// + /// + /// "System.Int32[]" for int[]
+ /// "System.Collections.Generic.List" for List<string> + /// "System.Environment.SpecialFolder" for Environment.SpecialFolder + /// + string FullName { get; } + + /// + /// Gets the short name of the class the return type is pointing to. + /// + /// + /// "Int32[]" for int[]
+ /// "List" for List<string> + /// "SpecialFolder" for Environment.SpecialFolder + /// + string Name { get; } + + /// + /// Gets the full reflection name of the element. + /// + /// + /// For types, the reflection name can be parsed back into a ITypeReference by using + /// . + /// + /// + /// "System.Int32[]" for int[]
+ /// "System.Int32[][,]" for C# int[,][]
+ /// "System.Collections.Generic.List`1[[System.String]]" for List<string> + /// "System.Environment+SpecialFolder" for Environment.SpecialFolder + /// + string ReflectionName { get; } + + /// + /// Gets the full name of the namespace containing this entity. + /// + string Namespace { get; } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/INamespace.cs b/src/ICSharpCode.Decompiler/TypeSystem/INamespace.cs new file mode 100644 index 0000000..353fd63 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/INamespace.cs @@ -0,0 +1,87 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Represents a resolved namespace. + /// + public interface INamespace : ISymbol, ICompilationProvider + { + // No pointer back to unresolved namespace: + // multiple unresolved namespaces (from different assemblies) get + // merged into one INamespace. + + /// + /// Gets the extern alias for this namespace. + /// Returns an empty string for normal namespaces. + /// + string ExternAlias { get; } + + /// + /// Gets the full name of this namespace. (e.g. "System.Collections") + /// + string FullName { get; } + + /// + /// Gets the short name of this namespace (e.g. "Collections"). + /// + new string Name { get; } + + /// + /// Gets the parent namespace. + /// Returns null if this is the root namespace. + /// + INamespace ParentNamespace { get; } + + /// + /// Gets the child namespaces in this namespace. + /// + IEnumerable ChildNamespaces { get; } + + /// + /// Gets the types in this namespace. + /// + IEnumerable Types { get; } + + /// + /// Gets the modules that contribute types to this namespace (or to child namespaces). + /// + IEnumerable ContributingModules { get; } + + /// + /// Gets a direct child namespace by its short name. + /// Returns null when the namespace cannot be found. + /// + /// + /// This method uses the compilation's current string comparer. + /// + INamespace GetChildNamespace(string name); + + /// + /// Gets the type with the specified short name and type parameter count. + /// Returns null if the type cannot be found. + /// + /// + /// This method uses the compilation's current string comparer. + /// + ITypeDefinition GetTypeDefinition(string name, int typeParameterCount); + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IParameter.cs b/src/ICSharpCode.Decompiler/TypeSystem/IParameter.cs new file mode 100644 index 0000000..71e2d6f --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IParameter.cs @@ -0,0 +1,91 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Runtime.CompilerServices; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public enum ReferenceKind + { + None, + Out, + Ref, + In + } + + public interface IParameter : IVariable + { + /// + /// Gets the attributes on this parameter. + /// + IEnumerable GetAttributes(); + + /// + /// Gets the reference kind of this parameter. + /// + ReferenceKind ReferenceKind { get; } + + /// + /// Gets whether this parameter is a C# 'ref' parameter. + /// + bool IsRef { get; } + + /// + /// Gets whether this parameter is a C# 'out' parameter. + /// + bool IsOut { get; } + + /// + /// Gets whether this parameter is a C# 'in' parameter. + /// + bool IsIn { get; } + + /// + /// Gets whether this parameter is a C# 'params' parameter. + /// + bool IsParams { get; } + + /// + /// Gets whether this parameter is optional. + /// The default value is given by the function. + /// + bool IsOptional { get; } + + /// + /// Gets whether this parameter has a constant value when presented in method signature. + /// + /// + /// This can only be true if the parameter is optional, and it's true for most + /// optional parameters. However it is possible to compile a parameter without a default value, + /// and some parameters handle their default values in an special way. + /// + /// For example, does not use normal constants, + /// we expose DecimalConstantAttribute directly instead of a constant value. + /// + /// On the call sites, though, we can still use the value inferred from the attribute. + /// + bool HasConstantValueInSignature { get; } + + /// + /// Gets the owner of this parameter. + /// May return null; for example when parameters belong to lambdas or anonymous methods. + /// + IParameterizedMember Owner { get; } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IParameterizedMember.cs b/src/ICSharpCode.Decompiler/TypeSystem/IParameterizedMember.cs new file mode 100644 index 0000000..7f7e055 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IParameterizedMember.cs @@ -0,0 +1,30 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Represents a method or property. + /// + public interface IParameterizedMember : IMember + { + IReadOnlyList Parameters { get; } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IProperty.cs b/src/ICSharpCode.Decompiler/TypeSystem/IProperty.cs new file mode 100644 index 0000000..56673e5 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IProperty.cs @@ -0,0 +1,39 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Represents a property or indexer. + /// + public interface IProperty : IParameterizedMember + { + bool CanGet { get; } + bool CanSet { get; } + + IMethod Getter { get; } + IMethod Setter { get; } + + bool IsIndexer { get; } + + /// + /// Gets whether the return type is 'ref readonly'. + /// + bool ReturnTypeIsRefReadOnly { get; } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ISupportsInterning.cs b/src/ICSharpCode.Decompiler/TypeSystem/ISupportsInterning.cs new file mode 100644 index 0000000..dfab4ea --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ISupportsInterning.cs @@ -0,0 +1,37 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Interface for TypeSystem objects that support interning. + /// See for more information. + /// + public interface ISupportsInterning + { + /// + /// Gets a hash code for interning. + /// + int GetHashCodeForInterning(); + + /// + /// Equality test for interning. + /// + bool EqualsForInterning(ISupportsInterning other); + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ISymbol.cs b/src/ICSharpCode.Decompiler/TypeSystem/ISymbol.cs new file mode 100644 index 0000000..6bfcd5b --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ISymbol.cs @@ -0,0 +1,98 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public enum SymbolKind : byte + { + None, + /// + Module, + /// + TypeDefinition, + /// + Field, + /// + /// The symbol is a property, but not an indexer. + /// + /// + Property, + /// + /// The symbol is an indexer, not a regular property. + /// + /// + Indexer, + /// + Event, + /// + /// The symbol is a method which is not an operator/constructor/destructor or accessor. + /// + /// + Method, + /// + /// The symbol is a user-defined operator. + /// + /// + Operator, + /// + Constructor, + /// + Destructor, + /// + /// The accessor method for a property getter/setter or event add/remove. + /// + /// + Accessor, + /// + Namespace, + /// + /// The symbol is a variable, but not a parameter. + /// + /// + Variable, + /// + Parameter, + /// + TypeParameter, + /// + /// Constraint on a type parameter. + /// + Constraint, + /// + /// Return type. Not actually an ISymbol implementation; but can appear as attribut target. + /// + ReturnType, + } + + /// + /// Interface for type system symbols. + /// + public interface ISymbol + { + /// + /// This property returns an enum specifying which kind of symbol this is + /// (which derived interfaces of ISymbol are implemented) + /// + SymbolKind SymbolKind { get; } + + /// + /// Gets the short name of the symbol. + /// + string Name { get; } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IType.cs b/src/ICSharpCode.Decompiler/TypeSystem/IType.cs new file mode 100644 index 0000000..c9725d0 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IType.cs @@ -0,0 +1,346 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// This interface represents a resolved type in the type system. + /// + /// + /// + /// A type is potentially + /// - a type definition (, i.e. a class, struct, interface, delegate, or built-in primitive type) + /// - a parameterized type (, e.g. List<int>) + /// - a type parameter (, e.g. T) + /// - an array () + /// - a pointer () + /// - a managed reference () + /// - one of the special types (, , + /// , ) + /// + /// The property can be used to switch on the kind of a type. + /// + /// + /// IType uses the null object pattern: serves as the null object. + /// Methods or properties returning IType never return null unless documented otherwise. + /// + /// + /// Types should be compared for equality using the method. + /// Identical types do not necessarily use the same object reference. + /// + /// + public interface IType : INamedElement, IEquatable + { + /// + /// Gets the type kind. + /// + TypeKind Kind { get; } + + /// + /// Gets whether the type is a reference type or value type. + /// + /// + /// true, if the type is a reference type. + /// false, if the type is a value type. + /// null, if the type is not known (e.g. unconstrained generic type parameter or type not found) + /// + bool? IsReferenceType { get; } + + /// + /// Gets whether this type is "ref-like": a ByReferenceType or "ref struct". + /// + bool IsByRefLike { get; } + + /// + /// Gets the nullability annotation on this type. + /// + Nullability Nullability { get; } + + /// + /// Creates a new type that is a copy of this type, with the changed nullability annotation. + /// + IType ChangeNullability(Nullability newNullability); + + /// + /// Gets the underlying type definition. + /// Can return null for types which do not have a type definition (for example arrays, pointers, type parameters). + /// + ITypeDefinition GetDefinition(); + + /// + /// Gets the parent type, if this is a nested type. + /// Returns null for top-level types. + /// + IType DeclaringType { get; } + + /// + /// Gets the number of type parameters. + /// + int TypeParameterCount { get; } + + /// + /// Gets the type parameters. + /// Returns an empty list if this type is not generic. + /// + IReadOnlyList TypeParameters { get; } + + /// + /// Gets the type arguments passed to this type. + /// If this type is a generic type definition that is not parameterized, this property returns the type parameters, + /// as if the type was parameterized with its own type arguments (class C<T> { C<T> field; }). + /// + IReadOnlyList TypeArguments { get; } + + /// + /// Calls ITypeVisitor.Visit for this type. + /// + /// The return value of the ITypeVisitor.Visit call + IType AcceptVisitor(TypeVisitor visitor); + + /// + /// Calls ITypeVisitor.Visit for all children of this type, and reconstructs this type with the children based + /// on the return values of the visit calls. + /// + /// A copy of this type, with all children replaced by the return value of the corresponding visitor call. + /// If the visitor returned the original types for all children (or if there are no children), returns this. + /// + IType VisitChildren(TypeVisitor visitor); + + /// + /// Gets the direct base types. + /// + /// Returns the direct base types including interfaces + IEnumerable DirectBaseTypes { get; } + + /// + /// Gets a type visitor that performs the substitution of class type parameters with the type arguments + /// of this parameterized type. + /// Returns TypeParameterSubstitution.Identity if the type is not parametrized. + /// + TypeParameterSubstitution GetSubstitution(); + + /// + /// Gets inner classes (including inherited inner classes). + /// + /// The filter used to select which types to return. + /// The filter is tested on the original type definitions (before parameterization). + /// Specified additional options for the GetMembers() operation. + /// + /// + /// If the nested type is generic, this method will return a parameterized type, + /// where the additional type parameters are set to . + /// + /// + /// Type parameters belonging to the outer class will have the value copied from the outer type + /// if it is a parameterized type. Otherwise, those existing type parameters will be self-parameterized, + /// and thus 'leaked' to the caller in the same way the GetMembers() method does not specialize members + /// from an and 'leaks' type parameters in member signatures. + /// + /// + /// + /// + /// class Base<T> { + /// class Nested<X> {} + /// } + /// class Derived<A, B> : Base<B> {} + /// + /// Derived[string,int].GetNestedTypes() = { Base`1+Nested`1[int, unbound] } + /// Derived.GetNestedTypes() = { Base`1+Nested`1[`1, unbound] } + /// Base[`1].GetNestedTypes() = { Base`1+Nested`1[`1, unbound] } + /// Base.GetNestedTypes() = { Base`1+Nested`1[`0, unbound] } + /// + /// + IEnumerable GetNestedTypes(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None); + + // Note that we cannot 'leak' the additional type parameter as we leak the normal type parameters, because + // the index might collide. For example, + // class Base { class Nested {} } + // class Derived : Base { } + // + // Derived.GetNestedTypes() = Base+Nested + // Derived.GetNestedTypes() = Base+Nested<`1, > + // Here `1 refers to B, and there's no way to return X as it would collide with B. + + /// + /// Gets inner classes (including inherited inner classes) + /// that have typeArguments.Count additional type parameters. + /// + /// The type arguments passed to the inner class + /// The filter used to select which types to return. + /// The filter is tested on the original type definitions (before parameterization). + /// Specified additional options for the GetMembers() operation. + /// + /// Type parameters belonging to the outer class will have the value copied from the outer type + /// if it is a parameterized type. Otherwise, those existing type parameters will be self-parameterized, + /// and thus 'leaked' to the caller in the same way the GetMembers() method does not specialize members + /// from an and 'leaks' type parameters in member signatures. + /// + IEnumerable GetNestedTypes(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None); + + /// + /// Gets all instance constructors for this type. + /// + /// The filter used to select which constructors to return. + /// The filter is tested on the original method definitions (before specialization). + /// Specified additional options for the GetMembers() operation. + /// + /// The result does not include static constructors. + /// Constructors in base classes are not returned by default, as GetMemberOptions.IgnoreInheritedMembers is the default value. + /// + /// For methods on parameterized types, type substitution will be performed on the method signature, + /// and the appropriate will be returned. + /// + /// + IEnumerable GetConstructors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.IgnoreInheritedMembers); + + /// + /// Gets all methods that can be called on this type. + /// + /// The filter used to select which methods to return. + /// The filter is tested on the original method definitions (before specialization). + /// Specified additional options for the GetMembers() operation. + /// + /// + /// The result does not include constructors or accessors. + /// + /// + /// For methods on parameterized types, type substitution will be performed on the method signature, + /// and the appropriate will be returned. + /// + /// + /// If the method being returned is generic, and this type is a parameterized type where the type + /// arguments involve another method's type parameters, the resulting specialized signature + /// will be ambiguous as to which method a type parameter belongs to. + /// For example, "List[[``0]].GetMethods()" will return "ConvertAll(Converter`2[[``0, ``0]])". + /// + /// If possible, use the other GetMethods() overload to supply type arguments to the method, + /// so that both class and method type parameter can be substituted at the same time, so that + /// the ambiguity can be avoided. + /// + /// + IEnumerable GetMethods(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None); + + /// + /// Gets all generic methods that can be called on this type with the specified type arguments. + /// + /// The type arguments used for the method call. + /// The filter used to select which methods to return. + /// The filter is tested on the original method definitions (before specialization). + /// Specified additional options for the GetMembers() operation. + /// + /// The result does not include constructors or accessors. + /// + /// Type substitution will be performed on the method signature, creating a + /// with the specified type arguments. + /// + /// + /// When the list of type arguments is empty, this method acts like the GetMethods() overload without + /// the type arguments parameter - that is, it also returns generic methods, + /// and the other overload's remarks about ambiguous signatures apply here as well. + /// + /// + IEnumerable GetMethods(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None); + + /// + /// Gets all properties that can be called on this type. + /// + /// The filter used to select which properties to return. + /// The filter is tested on the original property definitions (before specialization). + /// Specified additional options for the GetMembers() operation. + /// + /// For properties on parameterized types, type substitution will be performed on the property signature, + /// and the appropriate will be returned. + /// + IEnumerable GetProperties(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None); + + /// + /// Gets all fields that can be accessed on this type. + /// + /// The filter used to select which constructors to return. + /// The filter is tested on the original field definitions (before specialization). + /// Specified additional options for the GetMembers() operation. + /// + /// For fields on parameterized types, type substitution will be performed on the field's return type, + /// and the appropriate will be returned. + /// + IEnumerable GetFields(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None); + + /// + /// Gets all events that can be accessed on this type. + /// + /// The filter used to select which events to return. + /// The filter is tested on the original event definitions (before specialization). + /// Specified additional options for the GetMembers() operation. + /// + /// For fields on parameterized types, type substitution will be performed on the event's return type, + /// and the appropriate will be returned. + /// + IEnumerable GetEvents(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None); + + /// + /// Gets all members that can be called on this type. + /// + /// The filter used to select which members to return. + /// The filter is tested on the original member definitions (before specialization). + /// Specified additional options for the GetMembers() operation. + /// + /// + /// The resulting list is the union of GetFields(), GetProperties(), GetMethods() and GetEvents(). + /// It does not include constructors. + /// For parameterized types, type substitution will be performed. + /// + /// + /// For generic methods, the remarks about ambiguous signatures from the + /// method apply here as well. + /// + /// + IEnumerable GetMembers(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None); + + /// + /// Gets all accessors belonging to properties or events on this type. + /// + /// The filter used to select which members to return. + /// The filter is tested on the original member definitions (before specialization). + /// Specified additional options for the GetMembers() operation. + /// + /// Accessors are not returned by GetMembers() or GetMethods(). + /// + IEnumerable GetAccessors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None); + } + + [Flags] + public enum GetMemberOptions + { + /// + /// No options specified - this is the default. + /// Members will be specialized, and inherited members will be included. + /// + None = 0x00, + /// + /// Do not specialize the returned members - directly return the definitions. + /// + ReturnMemberDefinitions = 0x01, + /// + /// Do not list inherited members - only list members defined directly on this type. + /// + IgnoreInheritedMembers = 0x02 + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ITypeDefinition.cs b/src/ICSharpCode.Decompiler/TypeSystem/ITypeDefinition.cs new file mode 100644 index 0000000..e0e796c --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ITypeDefinition.cs @@ -0,0 +1,77 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Represents a class, enum, interface, struct, delegate or VB module. + /// For partial classes, this represents the whole class. + /// + public interface ITypeDefinition : IType, IEntity + { + IReadOnlyList NestedTypes { get; } + IReadOnlyList Members { get; } + + IEnumerable Fields { get; } + IEnumerable Methods { get; } + IEnumerable Properties { get; } + IEnumerable Events { get; } + + /// + /// Gets the known type code for this type definition. + /// + KnownTypeCode KnownTypeCode { get; } + + /// + /// For enums: returns the underlying primitive type. + /// For all other types: returns . + /// + IType EnumUnderlyingType { get; } + + /// + /// For structs: returns whether this is a readonly struct. + /// For all other types: returns false. + /// + bool IsReadOnly { get; } + + /// + /// Gets the full name of this type. + /// + FullTypeName FullTypeName { get; } + + /// + /// Gets/Sets the declaring type (incl. type arguments, if any). + /// This property will return null for top-level types. + /// + new IType DeclaringType { get; } // solves ambiguity between IType.DeclaringType and IEntity.DeclaringType + + /// + /// Gets whether this type contains extension methods. + /// + /// This property is used to speed up the search for extension methods. + bool HasExtensionMethods { get; } + + /// + /// The nullability specified in the [NullableContext] attribute on the type. + /// This serves as default nullability for members of the type that do not have a [Nullable] attribute. + /// + Nullability NullableContext { get; } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ITypeParameter.cs b/src/ICSharpCode.Decompiler/TypeSystem/ITypeParameter.cs new file mode 100644 index 0000000..4079d27 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ITypeParameter.cs @@ -0,0 +1,140 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Type parameter of a generic class/method. + /// + public interface ITypeParameter : IType, ISymbol + { + /// + /// Get the type of this type parameter's owner. + /// + /// SymbolKind.TypeDefinition or SymbolKind.Method + SymbolKind OwnerType { get; } + + /// + /// Gets the owning method/class. + /// This property may return null (for example for the dummy type parameters used by ). + /// + /// + /// For "class Outer<T> { class Inner {} }", + /// inner.TypeParameters[0].Owner will be the outer class, because the same + /// ITypeParameter instance is used both on Outer`1 and Outer`1+Inner. + /// + IEntity Owner { get; } + + /// + /// Gets the index of the type parameter in the type parameter list of the owning method/class. + /// + int Index { get; } + + /// + /// Gets the name of the type parameter. + /// + new string Name { get; } + + /// + /// Gets the attributes declared on this type parameter. + /// + IEnumerable GetAttributes(); + + /// + /// Gets the variance of this type parameter. + /// + VarianceModifier Variance { get; } + + /// + /// Gets the effective base class of this type parameter. + /// + IType EffectiveBaseClass { get; } + + /// + /// Gets the effective interface set of this type parameter. + /// + IReadOnlyCollection EffectiveInterfaceSet { get; } + + /// + /// Gets if the type parameter has the 'new()' constraint. + /// + bool HasDefaultConstructorConstraint { get; } + + /// + /// Gets if the type parameter has the 'class' constraint. + /// + bool HasReferenceTypeConstraint { get; } + + /// + /// Gets if the type parameter has the 'struct' or 'unmanaged' constraint. + /// + bool HasValueTypeConstraint { get; } + + /// + /// Gets if the type parameter has the 'unmanaged' constraint. + /// + bool HasUnmanagedConstraint { get; } + + /// + /// Nullability of the reference type constraint. (e.g. "where T : class?"). + /// + /// Note that the nullability of a use of the type parameter may differ from this. + /// E.g. "T? GetNull<T>() where T : class => null;" + /// + Nullability NullabilityConstraint { get; } + + IReadOnlyList TypeConstraints { get; } + } + + public readonly struct TypeConstraint + { + public SymbolKind SymbolKind => SymbolKind.Constraint; + public IType Type { get; } + public IReadOnlyList Attributes { get; } + + public TypeConstraint(IType type, IReadOnlyList attributes = null) + { + this.Type = type ?? throw new ArgumentNullException(nameof(type)); + this.Attributes = attributes ?? EmptyList.Instance; + } + } + + /// + /// Represents the variance of a type parameter. + /// + public enum VarianceModifier : byte + { + /// + /// The type parameter is not variant. + /// + Invariant, + /// + /// The type parameter is covariant (used in output position). + /// + Covariant, + /// + /// The type parameter is contravariant (used in input position). + /// + Contravariant + }; +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ITypeReference.cs b/src/ICSharpCode.Decompiler/TypeSystem/ITypeReference.cs new file mode 100644 index 0000000..92ef084 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ITypeReference.cs @@ -0,0 +1,71 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Represents a reference to a type. + /// Must be resolved before it can be used as type. + /// + public interface ITypeReference + { + // Keep this interface simple: I decided against having GetMethods/GetEvents etc. here, + // so that the Resolve step is never hidden from the consumer. + + // I decided against implementing IFreezable here: IUnresolvedTypeDefinition can be used as ITypeReference, + // but when freezing the reference, one wouldn't expect the definition to freeze. + + /// + /// Resolves this type reference. + /// + /// + /// Context to use for resolving this type reference. + /// Which kind of context is required depends on the which kind of type reference this is; + /// please consult the documentation of the method that was used to create this type reference, + /// or that of the class implementing this method. + /// + /// + /// Returns the resolved type. + /// In case of an error, returns an unknown type (). + /// Never returns null. + /// + IType Resolve(ITypeResolveContext context); + } + + public interface ITypeResolveContext : ICompilationProvider + { + /// + /// Gets the current module. + /// This property may return null if this context does not specify any module. + /// + IModule CurrentModule { get; } + + /// + /// Gets the current type definition. + /// + ITypeDefinition CurrentTypeDefinition { get; } + + /// + /// Gets the current member. + /// + IMember CurrentMember { get; } + + ITypeResolveContext WithCurrentTypeDefinition(ITypeDefinition typeDefinition); + ITypeResolveContext WithCurrentMember(IMember member); + } +} \ No newline at end of file diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IVariable.cs b/src/ICSharpCode.Decompiler/TypeSystem/IVariable.cs new file mode 100644 index 0000000..13e1c27 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IVariable.cs @@ -0,0 +1,47 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Represents a variable (name/type pair). + /// + public interface IVariable : ISymbol + { + /// + /// Gets the name of the variable. + /// + new string Name { get; } + + /// + /// Gets the type of the variable. + /// + IType Type { get; } + + /// + /// Gets whether this variable is a constant (C#-like const). + /// + bool IsConst { get; } + + /// + /// If this field is a constant, retrieves the value. + /// For parameters, this is the default value. + /// + object GetConstantValue(bool throwOnInvalidMetadata = false); + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractFreezable.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractFreezable.cs new file mode 100644 index 0000000..2d5d0d6 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractFreezable.cs @@ -0,0 +1,118 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Linq; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + public static class FreezableHelper + { + public static void ThrowIfFrozen(IFreezable freezable) + { + if (freezable.IsFrozen) + throw new InvalidOperationException("Cannot mutate frozen " + freezable.GetType().Name); + } + + public static IList FreezeListAndElements(IList list) + { + if (list != null) + { + foreach (var item in list) + Freeze(item); + } + return FreezeList(list); + } + + public static IList FreezeList(IList list) + { + if (list == null || list.Count == 0) + return EmptyList.Instance; + if (list.IsReadOnly) + { + // If the list is already read-only, return it directly. + // This is important, otherwise we might undo the effects of interning. + return list; + } + else + { + return new ReadOnlyCollection(list.ToArray()); + } + } + + public static void Freeze(object item) + { + var f = item as IFreezable; + if (f != null) + f.Freeze(); + } + + public static T FreezeAndReturn(T item) where T : IFreezable + { + item.Freeze(); + return item; + } + + /// + /// If the item is not frozen, this method creates and returns a frozen clone. + /// If the item is already frozen, it is returned without creating a clone. + /// + public static T GetFrozenClone(T item) where T : IFreezable, ICloneable + { + if (!item.IsFrozen) + { + item = (T)item.Clone(); + item.Freeze(); + } + return item; + } + } + + [Serializable] + public abstract class AbstractFreezable : IFreezable + { + bool isFrozen; + + /// + /// Gets if this instance is frozen. Frozen instances are immutable and thus thread-safe. + /// + public bool IsFrozen { + get { return isFrozen; } + } + + /// + /// Freezes this instance. + /// + public void Freeze() + { + if (!isFrozen) + { + FreezeInternal(); + isFrozen = true; + } + } + + protected virtual void FreezeInternal() + { + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractType.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractType.cs new file mode 100644 index 0000000..81b3bdf --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractType.cs @@ -0,0 +1,192 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Default implementation for IType interface. + /// + [Serializable] + public abstract class AbstractType : IType + { + public virtual string FullName { + get { + var ns = this.Namespace; + var name = this.Name; + if (string.IsNullOrEmpty(ns)) + { + return name; + } + else + { + return ns + "." + name; + } + } + } + + public abstract string Name { get; } + + public virtual string Namespace { + get { return string.Empty; } + } + + public virtual string ReflectionName { + get { return this.FullName; } + } + + public abstract bool? IsReferenceType { get; } + + public virtual bool IsByRefLike => false; + + public virtual Nullability Nullability => Nullability.Oblivious; + + public virtual IType ChangeNullability(Nullability nullability) + { + Debug.Assert(nullability == Nullability.Oblivious); + return this; + } + + public abstract TypeKind Kind { get; } + + public virtual int TypeParameterCount { + get { return 0; } + } + + public virtual IReadOnlyList TypeParameters { + get { return EmptyList.Instance; } + } + + public virtual IReadOnlyList TypeArguments { + get { return EmptyList.Instance; } + } + + public virtual IType DeclaringType { + get { return null; } + } + + public virtual ITypeDefinition GetDefinition() + { + return null; + } + + public virtual IEnumerable DirectBaseTypes { + get { return EmptyList.Instance; } + } + + public virtual IEnumerable GetNestedTypes(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return EmptyList.Instance; + } + + public virtual IEnumerable GetNestedTypes(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return EmptyList.Instance; + } + + public virtual IEnumerable GetMethods(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return EmptyList.Instance; + } + + public virtual IEnumerable GetMethods(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return EmptyList.Instance; + } + + public virtual IEnumerable GetConstructors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.IgnoreInheritedMembers) + { + return EmptyList.Instance; + } + + public virtual IEnumerable GetProperties(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return EmptyList.Instance; + } + + public virtual IEnumerable GetFields(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return EmptyList.Instance; + } + + public virtual IEnumerable GetEvents(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return EmptyList.Instance; + } + + public virtual IEnumerable GetMembers(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + IEnumerable members = GetMethods(filter, options); + return members + .Concat(GetProperties(filter, options)) + .Concat(GetFields(filter, options)) + .Concat(GetEvents(filter, options)); + } + + public virtual IEnumerable GetAccessors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return EmptyList.Instance; + } + + public TypeParameterSubstitution GetSubstitution() + { + return TypeParameterSubstitution.Identity; + } + + public TypeParameterSubstitution GetSubstitution(IReadOnlyList methodTypeArguments) + { + return TypeParameterSubstitution.Identity; + } + + public override sealed bool Equals(object obj) + { + return Equals(obj as IType); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public virtual bool Equals(IType other) + { + return this == other; // use reference equality by default + } + + public override string ToString() + { + return this.ReflectionName; + } + + public virtual IType AcceptVisitor(TypeVisitor visitor) + { + return visitor.VisitOtherType(this); + } + + public virtual IType VisitChildren(TypeVisitor visitor) + { + return this; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractTypeParameter.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractTypeParameter.cs new file mode 100644 index 0000000..a8d7f73 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/AbstractTypeParameter.cs @@ -0,0 +1,402 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Linq; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + public abstract class AbstractTypeParameter : ITypeParameter, ICompilationProvider + { + readonly ICompilation compilation; + readonly SymbolKind ownerType; + readonly IEntity owner; + readonly int index; + readonly string name; + readonly VarianceModifier variance; + + protected AbstractTypeParameter(IEntity owner, int index, string name, VarianceModifier variance) + { + if (owner == null) + throw new ArgumentNullException(nameof(owner)); + this.owner = owner; + this.compilation = owner.Compilation; + this.ownerType = owner.SymbolKind; + this.index = index; + this.name = name ?? ((this.OwnerType == SymbolKind.Method ? "!!" : "!") + index.ToString(CultureInfo.InvariantCulture)); + this.variance = variance; + } + + protected AbstractTypeParameter(ICompilation compilation, SymbolKind ownerType, int index, string name, VarianceModifier variance) + { + if (compilation == null) + throw new ArgumentNullException(nameof(compilation)); + this.compilation = compilation; + this.ownerType = ownerType; + this.index = index; + this.name = name ?? ((this.OwnerType == SymbolKind.Method ? "!!" : "!") + index.ToString(CultureInfo.InvariantCulture)); + this.variance = variance; + } + + SymbolKind ISymbol.SymbolKind { + get { return SymbolKind.TypeParameter; } + } + + public SymbolKind OwnerType { + get { return ownerType; } + } + + public IEntity Owner { + get { return owner; } + } + + public int Index { + get { return index; } + } + + public abstract IEnumerable GetAttributes(); + + public VarianceModifier Variance { + get { return variance; } + } + + public ICompilation Compilation { + get { return compilation; } + } + + volatile IType effectiveBaseClass; + + public IType EffectiveBaseClass { + get { + if (effectiveBaseClass == null) + { + // protect against cyclic type parameters + using (var busyLock = BusyManager.Enter(this)) + { + if (!busyLock.Success) + return SpecialType.UnknownType; // don't cache this error + effectiveBaseClass = CalculateEffectiveBaseClass(); + } + } + return effectiveBaseClass; + } + } + + IType CalculateEffectiveBaseClass() + { + if (HasValueTypeConstraint) + return this.Compilation.FindType(KnownTypeCode.ValueType); + + var classTypeConstraints = new List(); + foreach (var constraint in this.DirectBaseTypes) + { + if (constraint.Kind == TypeKind.Class) + { + classTypeConstraints.Add(constraint); + } + else if (constraint.Kind == TypeKind.TypeParameter) + { + var baseClass = ((ITypeParameter)constraint).EffectiveBaseClass; + if (baseClass.Kind == TypeKind.Class) + classTypeConstraints.Add(baseClass); + } + } + if (classTypeConstraints.Count == 0) + return this.Compilation.FindType(KnownTypeCode.Object); + // Find the derived-most type in the resulting set: + var result = classTypeConstraints[0]; + for (var i = 1; i < classTypeConstraints.Count; i++) + { + if (classTypeConstraints[i].GetDefinition().IsDerivedFrom(result.GetDefinition())) + result = classTypeConstraints[i]; + } + return result; + } + + IReadOnlyCollection effectiveInterfaceSet; + + public IReadOnlyCollection EffectiveInterfaceSet { + get { + var result = LazyInit.VolatileRead(ref effectiveInterfaceSet); + if (result != null) + { + return result; + } + else + { + // protect against cyclic type parameters + using (var busyLock = BusyManager.Enter(this)) + { + if (!busyLock.Success) + return EmptyList.Instance; // don't cache this error + return LazyInit.GetOrSet(ref effectiveInterfaceSet, CalculateEffectiveInterfaceSet()); + } + } + } + } + + IReadOnlyCollection CalculateEffectiveInterfaceSet() + { + var result = new HashSet(); + foreach (var constraint in this.DirectBaseTypes) + { + if (constraint.Kind == TypeKind.Interface) + { + result.Add(constraint); + } + else if (constraint.Kind == TypeKind.TypeParameter) + { + result.UnionWith(((ITypeParameter)constraint).EffectiveInterfaceSet); + } + } + return result.ToArray(); + } + + public abstract bool HasDefaultConstructorConstraint { get; } + public abstract bool HasReferenceTypeConstraint { get; } + public abstract bool HasValueTypeConstraint { get; } + public abstract bool HasUnmanagedConstraint { get; } + public abstract Nullability NullabilityConstraint { get; } + + public TypeKind Kind { + get { return TypeKind.TypeParameter; } + } + + public bool? IsReferenceType { + get { + if (this.HasValueTypeConstraint) + return false; + if (this.HasReferenceTypeConstraint) + return true; + + // A type parameter is known to be a reference type if it has the reference type constraint + // or its effective base class is not object or System.ValueType. + var effectiveBaseClass = this.EffectiveBaseClass; + if (effectiveBaseClass.Kind == TypeKind.Class || effectiveBaseClass.Kind == TypeKind.Delegate) + { + var effectiveBaseClassDef = effectiveBaseClass.GetDefinition(); + if (effectiveBaseClassDef != null) + { + switch (effectiveBaseClassDef.KnownTypeCode) + { + case KnownTypeCode.Object: + case KnownTypeCode.ValueType: + case KnownTypeCode.Enum: + return null; + } + } + return true; + } + else if (effectiveBaseClass.Kind == TypeKind.Struct || effectiveBaseClass.Kind == TypeKind.Enum) + { + return false; + } + return null; + } + } + + bool IType.IsByRefLike => false; + Nullability IType.Nullability => Nullability.Oblivious; + + public IType ChangeNullability(Nullability nullability) + { + if (nullability == Nullability.Oblivious) + return this; + else + return new NullabilityAnnotatedTypeParameter(this, nullability); + } + + IType IType.DeclaringType { + get { return null; } + } + + int IType.TypeParameterCount { + get { return 0; } + } + + IReadOnlyList IType.TypeParameters { + get { return EmptyList.Instance; } + } + + IReadOnlyList IType.TypeArguments { + get { return EmptyList.Instance; } + } + + public IEnumerable DirectBaseTypes { + get { return TypeConstraints.Select(t => t.Type); } + } + + public abstract IReadOnlyList TypeConstraints { get; } + + public string Name { + get { return name; } + } + + string INamedElement.Namespace { + get { return string.Empty; } + } + + string INamedElement.FullName { + get { return name; } + } + + public string ReflectionName { + get { + return (this.OwnerType == SymbolKind.Method ? "``" : "`") + index.ToString(CultureInfo.InvariantCulture); + } + } + + ITypeDefinition IType.GetDefinition() + { + return null; + } + + public IType AcceptVisitor(TypeVisitor visitor) + { + return visitor.VisitTypeParameter(this); + } + + public IType VisitChildren(TypeVisitor visitor) + { + return this; + } + + IEnumerable IType.GetNestedTypes(Predicate filter, GetMemberOptions options) + { + return EmptyList.Instance; + } + + IEnumerable IType.GetNestedTypes(IReadOnlyList typeArguments, Predicate filter, GetMemberOptions options) + { + return EmptyList.Instance; + } + + public IEnumerable GetConstructors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.IgnoreInheritedMembers) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + if (this.HasDefaultConstructorConstraint || this.HasValueTypeConstraint) + { + var dummyCtor = FakeMethod.CreateDummyConstructor(compilation, this); + if (filter == null || filter(dummyCtor)) + { + return new[] { dummyCtor }; + } + } + return EmptyList.Instance; + } + else + { + return GetMembersHelper.GetConstructors(this, filter, options); + } + } + + public IEnumerable GetMethods(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + return EmptyList.Instance; + else + return GetMembersHelper.GetMethods(this, FilterNonStatic(filter), options); + } + + public IEnumerable GetMethods(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + return EmptyList.Instance; + else + return GetMembersHelper.GetMethods(this, typeArguments, FilterNonStatic(filter), options); + } + + public IEnumerable GetProperties(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + return EmptyList.Instance; + else + return GetMembersHelper.GetProperties(this, FilterNonStatic(filter), options); + } + + public IEnumerable GetFields(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + return EmptyList.Instance; + else + return GetMembersHelper.GetFields(this, FilterNonStatic(filter), options); + } + + public IEnumerable GetEvents(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + return EmptyList.Instance; + else + return GetMembersHelper.GetEvents(this, FilterNonStatic(filter), options); + } + + public IEnumerable GetMembers(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + return EmptyList.Instance; + else + return GetMembersHelper.GetMembers(this, FilterNonStatic(filter), options); + } + + public IEnumerable GetAccessors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + return EmptyList.Instance; + else + return GetMembersHelper.GetAccessors(this, FilterNonStatic(filter), options); + } + + TypeParameterSubstitution IType.GetSubstitution() + { + return TypeParameterSubstitution.Identity; + } + + static Predicate FilterNonStatic(Predicate filter) where T : class, IMember + { + if (filter == null) + return member => !member.IsStatic; + else + return member => !member.IsStatic && filter(member); + } + + public sealed override bool Equals(object obj) + { + return Equals(obj as IType); + } + + public override int GetHashCode() + { + return base.GetHashCode(); + } + + public virtual bool Equals(IType other) + { + return this == other; // use reference equality for type parameters + } + + public override string ToString() + { + return this.ReflectionName; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/AttributeListBuilder.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/AttributeListBuilder.cs new file mode 100644 index 0000000..0503a09 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/AttributeListBuilder.cs @@ -0,0 +1,404 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Linq; +using System.Reflection.Metadata; +using System.Runtime.InteropServices; + +using ICSharpCode.Decompiler.Metadata; +using ICSharpCode.Decompiler.Util; + +using SRM = System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + readonly struct AttributeListBuilder + { + readonly MetadataModule module; + readonly List attributes; + + public AttributeListBuilder(MetadataModule module) + { + Debug.Assert(module != null); + this.module = module; + this.attributes = new List(); + } + + public AttributeListBuilder(MetadataModule module, int capacity) + { + Debug.Assert(module != null); + this.module = module; + this.attributes = new List(capacity); + } + + public void Add(IAttribute attr) + { + attributes.Add(attr); + } + + /// + /// Add a builtin attribute without any arguments. + /// + public void Add(KnownAttribute type) + { + // use the assemblies' cache for simple attributes + Add(module.MakeAttribute(type)); + } + + /// + /// Construct a builtin attribute with a single positional argument of known type. + /// + public void Add(KnownAttribute type, KnownTypeCode argType, object argValue) + { + Add(type, ImmutableArray.Create(new CustomAttributeTypedArgument(module.Compilation.FindType(argType), argValue))); + } + + /// + /// Construct a builtin attribute with a single positional argument of known type. + /// + public void Add(KnownAttribute type, TopLevelTypeName argType, object argValue) + { + Add(type, ImmutableArray.Create(new CustomAttributeTypedArgument(module.Compilation.FindType(argType), argValue))); + } + + /// + /// Construct a builtin attribute. + /// + public void Add(KnownAttribute type, ImmutableArray> fixedArguments) + { + Add(new DefaultAttribute(module.GetAttributeType(type), fixedArguments, + ImmutableArray.Create>())); + } + + #region MarshalAsAttribute (ConvertMarshalInfo) + internal void AddMarshalInfo(BlobHandle marshalInfo) + { + if (marshalInfo.IsNil) + return; + var metadata = module.metadata; + Add(ConvertMarshalInfo(metadata.GetBlobReader(marshalInfo))); + } + + const string InteropServices = "System.Runtime.InteropServices"; + + IAttribute ConvertMarshalInfo(SRM.BlobReader marshalInfo) + { + var b = new AttributeBuilder(module, KnownAttribute.MarshalAs); + var unmanagedTypeType = module.Compilation.FindType(new TopLevelTypeName(InteropServices, nameof(UnmanagedType))); + + int type = marshalInfo.ReadByte(); + b.AddFixedArg(unmanagedTypeType, type); + + int size; + switch (type) + { + case 0x1e: // FixedArray + if (!marshalInfo.TryReadCompressedInteger(out size)) + size = 0; + b.AddNamedArg("SizeConst", KnownTypeCode.Int32, size); + if (marshalInfo.RemainingBytes > 0) + { + type = marshalInfo.ReadByte(); + if (type != 0x66) // None + b.AddNamedArg("ArraySubType", unmanagedTypeType, type); + } + break; + case 0x1d: // SafeArray + if (marshalInfo.RemainingBytes > 0) + { + var varType = (VarEnum)marshalInfo.ReadByte(); + if (varType != VarEnum.VT_EMPTY) + { + var varEnumType = new TopLevelTypeName(InteropServices, nameof(VarEnum)); + b.AddNamedArg("SafeArraySubType", varEnumType, (int)varType); + } + } + break; + case 0x2a: // NATIVE_TYPE_ARRAY + if (marshalInfo.RemainingBytes > 0) + { + type = marshalInfo.ReadByte(); + } + else + { + type = 0x66; // Cecil uses NativeType.None as default. + } + if (type != 0x50) + { // Max + b.AddNamedArg("ArraySubType", unmanagedTypeType, type); + } + var sizeParameterIndex = marshalInfo.TryReadCompressedInteger(out var value) ? value : -1; + size = marshalInfo.TryReadCompressedInteger(out value) ? value : -1; + var sizeParameterMultiplier = marshalInfo.TryReadCompressedInteger(out value) ? value : -1; + if (size >= 0) + { + b.AddNamedArg("SizeConst", KnownTypeCode.Int32, size); + } + if (sizeParameterMultiplier != 0 && sizeParameterIndex >= 0) + { + b.AddNamedArg("SizeParamIndex", KnownTypeCode.Int16, (short)sizeParameterIndex); + } + break; + case 0x2c: // CustomMarshaler + var guidValue = marshalInfo.ReadSerializedString(); + var unmanagedType = marshalInfo.ReadSerializedString(); + var managedType = marshalInfo.ReadSerializedString(); + var cookie = marshalInfo.ReadSerializedString(); + if (managedType != null) + { + b.AddNamedArg("MarshalType", KnownTypeCode.String, managedType); + } + if (!string.IsNullOrEmpty(cookie)) + { + b.AddNamedArg("MarshalCookie", KnownTypeCode.String, cookie); + } + break; + case 0x17: // FixedSysString + b.AddNamedArg("SizeConst", KnownTypeCode.Int32, marshalInfo.ReadCompressedInteger()); + break; + } + + return b.Build(); + } + #endregion + + #region Custom Attributes (ReadAttribute) + public void Add(CustomAttributeHandleCollection attributes, SymbolKind target) + { + var metadata = module.metadata; + foreach (var handle in attributes) + { + var attribute = metadata.GetCustomAttribute(handle); + // Attribute types shouldn't be generic (and certainly not open), so we don't need a generic context. + var ctor = module.ResolveMethod(attribute.Constructor, new GenericContext()); + var type = ctor.DeclaringType; + if (IgnoreAttribute(type, target)) + { + continue; + } + Add(new CustomAttribute(module, ctor, handle)); + } + } + + bool IgnoreAttribute(IType attributeType, SymbolKind target) + { + if (attributeType.DeclaringType != null || attributeType.TypeParameterCount != 0) + return false; + switch (attributeType.Namespace) + { + case "System.Runtime.CompilerServices": + switch (attributeType.Name) + { + case "DynamicAttribute": + return true; + case "NativeIntegerAttribute": + return true; + case "TupleElementNamesAttribute": + return true; + case "ExtensionAttribute": + return true; + case "DecimalConstantAttribute": + return (target == SymbolKind.Field || target == SymbolKind.Parameter); + case "IsReadOnlyAttribute": + switch (target) + { + case SymbolKind.TypeDefinition: + case SymbolKind.Parameter: + return true; + case SymbolKind.Method: + case SymbolKind.Accessor: + return true; + case SymbolKind.ReturnType: + case SymbolKind.Property: + case SymbolKind.Indexer: + return true; // "ref readonly" is currently always active + default: + return false; + } + case "IsByRefLikeAttribute": + return target == SymbolKind.TypeDefinition; + case "IsUnmanagedAttribute": + return target == SymbolKind.TypeParameter; + case "NullableAttribute": + return true; + case "NullableContextAttribute": + return (target == SymbolKind.TypeDefinition || target == SymbolKind.Method); + default: + return false; + } + case "System": + return attributeType.Name == "ParamArrayAttribute" && target == SymbolKind.Parameter; + default: + return false; + } + } + #endregion + + #region Security Attributes + public void AddSecurityAttributes(DeclarativeSecurityAttributeHandleCollection securityDeclarations) + { + var metadata = module.metadata; + foreach (var secDecl in securityDeclarations) + { + if (secDecl.IsNil) + continue; + try + { + AddSecurityAttributes(metadata.GetDeclarativeSecurityAttribute(secDecl)); + } + catch (EnumUnderlyingTypeResolveException) + { + // ignore resolve errors + } + catch (BadImageFormatException) + { + // ignore invalid security declarations + } + } + } + + public void AddSecurityAttributes(DeclarativeSecurityAttribute secDecl) + { + var securityActionType = module.Compilation.FindType(new TopLevelTypeName("System.Security.Permissions", "SecurityAction")); + var securityAction = new CustomAttributeTypedArgument(securityActionType, (int)secDecl.Action); + var metadata = module.metadata; + var reader = metadata.GetBlobReader(secDecl.PermissionSet); + if (reader.ReadByte() == '.') + { + // binary attribute + var attributeCount = reader.ReadCompressedInteger(); + for (var i = 0; i < attributeCount; i++) + { + Add(ReadBinarySecurityAttribute(ref reader, securityAction)); + } + } + else + { + // for backward compatibility with .NET 1.0: XML-encoded attribute + reader.Reset(); + Add(ReadXmlSecurityAttribute(ref reader, securityAction)); + } + } + + private IAttribute ReadXmlSecurityAttribute(ref SRM.BlobReader reader, CustomAttributeTypedArgument securityAction) + { + var xml = reader.ReadUTF16(reader.RemainingBytes); + var b = new AttributeBuilder(module, KnownAttribute.PermissionSet); + b.AddFixedArg(securityAction); + b.AddNamedArg("XML", KnownTypeCode.String, xml); + return b.Build(); + } + + private IAttribute ReadBinarySecurityAttribute(ref SRM.BlobReader reader, CustomAttributeTypedArgument securityAction) + { + var attributeTypeName = reader.ReadSerializedString(); + var attributeType = module.TypeProvider.GetTypeFromSerializedName(attributeTypeName); + + reader.ReadCompressedInteger(); // ?? + // The specification seems to be incorrect here, so I'm using the logic from Cecil instead. + var numNamed = reader.ReadCompressedInteger(); + + var decoder = new Metadata.CustomAttributeDecoder(module.TypeProvider, module.metadata); + var namedArgs = decoder.DecodeNamedArguments(ref reader, numNamed); + + return new DefaultAttribute( + attributeType, + fixedArguments: ImmutableArray.Create(securityAction), + namedArguments: namedArgs); + } + #endregion + + public IAttribute[] Build() + { + if (attributes.Count == 0) + return Empty.Array; + else + return attributes.ToArray(); + } + } + + struct AttributeBuilder + { + readonly ICompilation compilation; + readonly IType attributeType; + ImmutableArray>.Builder fixedArgs; + ImmutableArray>.Builder namedArgs; + + public AttributeBuilder(MetadataModule module, KnownAttribute attributeType) + : this(module, module.GetAttributeType(attributeType)) + { + } + + public AttributeBuilder(MetadataModule module, IType attributeType) + { + this.compilation = module.Compilation; + this.attributeType = attributeType; + this.fixedArgs = ImmutableArray.CreateBuilder>(); + this.namedArgs = ImmutableArray.CreateBuilder>(); + } + + public void AddFixedArg(CustomAttributeTypedArgument arg) + { + fixedArgs.Add(arg); + } + + public void AddFixedArg(KnownTypeCode type, object value) + { + AddFixedArg(compilation.FindType(type), value); + } + + public void AddFixedArg(TopLevelTypeName type, object value) + { + AddFixedArg(compilation.FindType(type), value); + } + + public void AddFixedArg(IType type, object value) + { + fixedArgs.Add(new CustomAttributeTypedArgument(type, value)); + } + + public void AddNamedArg(string name, KnownTypeCode type, object value) + { + AddNamedArg(name, compilation.FindType(type), value); + } + + public void AddNamedArg(string name, TopLevelTypeName type, object value) + { + AddNamedArg(name, compilation.FindType(type), value); + } + + public void AddNamedArg(string name, IType type, object value) + { + CustomAttributeNamedArgumentKind kind; + if (attributeType.GetFields(f => f.Name == name, GetMemberOptions.ReturnMemberDefinitions).Any()) + kind = CustomAttributeNamedArgumentKind.Field; + else + kind = CustomAttributeNamedArgumentKind.Property; + namedArgs.Add(new CustomAttributeNamedArgument(name, kind, type, value)); + } + + public IAttribute Build() + { + return new DefaultAttribute(attributeType, fixedArgs.ToImmutable(), namedArgs.ToImmutable()); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/BaseTypeCollector.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/BaseTypeCollector.cs new file mode 100644 index 0000000..ab866c8 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/BaseTypeCollector.cs @@ -0,0 +1,78 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Helper class for the GetAllBaseTypes() implementation. + /// + sealed class BaseTypeCollector : List + { + readonly Stack activeTypes = new Stack(); + + /// + /// If this option is enabled, the list will not contain interfaces when retrieving the base types + /// of a class. + /// + internal bool SkipImplementedInterfaces; + + public void CollectBaseTypes(IType type) + { + var def = type.GetDefinition() ?? type; + + // Maintain a stack of currently active type definitions, and avoid having one definition + // multiple times on that stack. + // This is necessary to ensure the output is finite in the presence of cyclic inheritance: + // class C : C> {} would not be caught by the 'no duplicate output' check, yet would + // produce infinite output. + if (activeTypes.Contains(def)) + return; + activeTypes.Push(def); + // Note that we also need to push non-type definitions, e.g. for protecting against + // cyclic inheritance in type parameters (where T : S where S : T). + // The output check doesn't help there because we call Add(type) only at the end. + // We can't simply call this.Add(type); at the start because that would return in an incorrect order. + + // Avoid outputting a type more than once - necessary for "diamond" multiple inheritance + // (e.g. C implements I1 and I2, and both interfaces derive from Object) + if (!this.Contains(type)) + { + foreach (var baseType in type.DirectBaseTypes) + { + if (SkipImplementedInterfaces && def != null && def.Kind != TypeKind.Interface && def.Kind != TypeKind.TypeParameter) + { + if (baseType.Kind == TypeKind.Interface) + { + // skip the interface + continue; + } + } + CollectBaseTypes(baseType); + } + // Add(type) at the end - we want a type to be output only after all its base types were added. + this.Add(type); + // Note that this is not the same as putting the this.Add() call in front and then reversing the list. + // For the diamond inheritance, Add() at the start produces "C, I1, Object, I2", + // while Add() at the end produces "Object, I1, I2, C". + } + activeTypes.Pop(); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/CustomAttribute.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/CustomAttribute.cs new file mode 100644 index 0000000..1c710e9 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/CustomAttribute.cs @@ -0,0 +1,124 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Linq; +using System.Reflection.Metadata; + +using ICSharpCode.Decompiler.Metadata; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Custom attribute loaded from metadata. + /// + sealed class CustomAttribute : IAttribute + { + readonly MetadataModule module; + readonly CustomAttributeHandle handle; + public IMethod Constructor { get; } + + // lazy-loaded: + CustomAttributeValue value; + bool valueDecoded; + bool hasDecodeErrors; + + internal CustomAttribute(MetadataModule module, IMethod attrCtor, CustomAttributeHandle handle) + { + Debug.Assert(module != null); + Debug.Assert(attrCtor != null); + Debug.Assert(!handle.IsNil); + this.module = module; + this.Constructor = attrCtor; + this.handle = handle; + } + + public IType AttributeType => Constructor.DeclaringType; + + public ImmutableArray> FixedArguments { + get { + DecodeValue(); + return value.FixedArguments; + } + } + + public ImmutableArray> NamedArguments { + get { + DecodeValue(); + return value.NamedArguments; + } + } + + public bool HasDecodeErrors { + get { + DecodeValue(); + return hasDecodeErrors; + } + } + + void DecodeValue() + { + lock (this) + { + try + { + if (!valueDecoded) + { + var metadata = module.metadata; + var attr = metadata.GetCustomAttribute(handle); + value = attr.DecodeValue(module.TypeProvider); + valueDecoded = true; + } + } + catch (EnumUnderlyingTypeResolveException) + { + value = new CustomAttributeValue( + ImmutableArray>.Empty, + ImmutableArray>.Empty + ); + hasDecodeErrors = true; + valueDecoded = true; // in case of errors, never try again. + } + catch (BadImageFormatException) + { + value = new CustomAttributeValue( + ImmutableArray>.Empty, + ImmutableArray>.Empty + ); + hasDecodeErrors = true; + valueDecoded = true; // in case of errors, never try again. + } + } + } + + internal static IMember MemberForNamedArgument(IType attributeType, CustomAttributeNamedArgument namedArgument) + { + switch (namedArgument.Kind) + { + case CustomAttributeNamedArgumentKind.Field: + return attributeType.GetFields(f => f.Name == namedArgument.Name).LastOrDefault(); + case CustomAttributeNamedArgumentKind.Property: + return attributeType.GetProperties(p => p.Name == namedArgument.Name).LastOrDefault(); + default: + return null; + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DecimalConstantHelper.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DecimalConstantHelper.cs new file mode 100644 index 0000000..ee9fcb8 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DecimalConstantHelper.cs @@ -0,0 +1,76 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + static class DecimalConstantHelper + { + public static bool AllowsDecimalConstants(MetadataModule module) + { + return true; + } + + public static bool IsDecimalConstant(MetadataModule module, CustomAttributeHandleCollection attributeHandles) + { + return attributeHandles.HasKnownAttribute(module.metadata, KnownAttribute.DecimalConstant); + } + + public static object GetDecimalConstantValue(MetadataModule module, CustomAttributeHandleCollection attributeHandles) + { + var metadata = module.metadata; + foreach (var attributeHandle in attributeHandles) + { + var attribute = metadata.GetCustomAttribute(attributeHandle); + if (attribute.IsKnownAttribute(metadata, KnownAttribute.DecimalConstant)) + return TryDecodeDecimalConstantAttribute(module, attribute); + } + return null; + } + + static decimal? TryDecodeDecimalConstantAttribute(MetadataModule module, System.Reflection.Metadata.CustomAttribute attribute) + { + var attrValue = attribute.DecodeValue(module.TypeProvider); + if (attrValue.FixedArguments.Length != 5) + return null; + // DecimalConstantAttribute has the arguments (byte scale, byte sign, uint hi, uint mid, uint low) or (byte scale, byte sign, int hi, int mid, int low) + // Both of these invoke the Decimal constructor (int lo, int mid, int hi, bool isNegative, byte scale) with explicit argument conversions if required. + if (!(attrValue.FixedArguments[0].Value is byte scale && attrValue.FixedArguments[1].Value is byte sign)) + return null; + unchecked + { + if (attrValue.FixedArguments[2].Value is uint hi + && attrValue.FixedArguments[3].Value is uint mid + && attrValue.FixedArguments[4].Value is uint lo) + { + return new decimal((int)lo, (int)mid, (int)hi, sign != 0, scale); + } + } + { + if (attrValue.FixedArguments[2].Value is int hi + && attrValue.FixedArguments[3].Value is int mid + && attrValue.FixedArguments[4].Value is int lo) + { + return new decimal(lo, mid, hi, sign != 0, scale); + } + } + return null; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DecoratedType.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DecoratedType.cs new file mode 100644 index 0000000..c5a7600 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DecoratedType.cs @@ -0,0 +1,108 @@ +using System; +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + public abstract class DecoratedType : IType + { + protected readonly IType baseType; + + protected DecoratedType(IType baseType) + { + this.baseType = baseType; + } + + TypeKind IType.Kind => baseType.Kind; + + bool? IType.IsReferenceType => baseType.IsReferenceType; + + bool IType.IsByRefLike => baseType.IsByRefLike; + + Nullability IType.Nullability => baseType.Nullability; + public abstract IType ChangeNullability(Nullability nullability); + + IType IType.DeclaringType => baseType.DeclaringType; + + int IType.TypeParameterCount => baseType.TypeParameterCount; + + IReadOnlyList IType.TypeParameters => baseType.TypeParameters; + + IReadOnlyList IType.TypeArguments => baseType.TypeArguments; + + IEnumerable IType.DirectBaseTypes => baseType.DirectBaseTypes; + + string INamedElement.FullName => baseType.FullName; + + string INamedElement.Name => baseType.Name; + + string INamedElement.ReflectionName => baseType.ReflectionName; + + string INamedElement.Namespace => baseType.Namespace; + + public abstract IType AcceptVisitor(TypeVisitor visitor); + + public abstract bool Equals(IType other); + + IEnumerable IType.GetAccessors(Predicate filter, GetMemberOptions options) + { + return baseType.GetAccessors(filter, options); + } + + IEnumerable IType.GetConstructors(Predicate filter, GetMemberOptions options) + { + return baseType.GetConstructors(filter, options); + } + + ITypeDefinition IType.GetDefinition() + { + return baseType.GetDefinition(); + } + + IEnumerable IType.GetEvents(Predicate filter, GetMemberOptions options) + { + return baseType.GetEvents(filter, options); + } + + IEnumerable IType.GetFields(Predicate filter, GetMemberOptions options) + { + return baseType.GetFields(filter, options); + } + + IEnumerable IType.GetMembers(Predicate filter, GetMemberOptions options) + { + return baseType.GetMembers(filter, options); + } + + IEnumerable IType.GetMethods(Predicate filter, GetMemberOptions options) + { + return baseType.GetMethods(filter, options); + } + + IEnumerable IType.GetMethods(IReadOnlyList typeArguments, Predicate filter, GetMemberOptions options) + { + return baseType.GetMethods(typeArguments, filter, options); + } + + IEnumerable IType.GetNestedTypes(Predicate filter, GetMemberOptions options) + { + return baseType.GetNestedTypes(filter, options); + } + + IEnumerable IType.GetNestedTypes(IReadOnlyList typeArguments, Predicate filter, GetMemberOptions options) + { + return baseType.GetNestedTypes(typeArguments, filter, options); + } + + IEnumerable IType.GetProperties(Predicate filter, GetMemberOptions options) + { + return baseType.GetProperties(filter, options); + } + + TypeParameterSubstitution IType.GetSubstitution() + { + return baseType.GetSubstitution(); + } + + public abstract IType VisitChildren(TypeVisitor visitor); + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultAssemblyReference.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultAssemblyReference.cs new file mode 100644 index 0000000..656c9d6 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultAssemblyReference.cs @@ -0,0 +1,86 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// References an existing assembly by name. + /// + [Serializable] + public sealed class DefaultAssemblyReference : IModuleReference, ISupportsInterning + { + public static readonly IModuleReference CurrentAssembly = new CurrentModuleReference(); + + readonly string shortName; + + public DefaultAssemblyReference(string assemblyName) + { + var pos = assemblyName != null ? assemblyName.IndexOf(',') : -1; + if (pos >= 0) + shortName = assemblyName.Substring(0, pos); + else + shortName = assemblyName; + } + + public IModule Resolve(ITypeResolveContext context) + { + var current = context.CurrentModule; + if (current != null && string.Equals(shortName, current.AssemblyName, StringComparison.OrdinalIgnoreCase)) + return current; + foreach (var asm in context.Compilation.Modules) + { + if (string.Equals(shortName, asm.AssemblyName, StringComparison.OrdinalIgnoreCase)) + return asm; + } + return null; + } + + public override string ToString() + { + return shortName; + } + + int ISupportsInterning.GetHashCodeForInterning() + { + unchecked + { + return shortName.GetHashCode(); + } + } + + bool ISupportsInterning.EqualsForInterning(ISupportsInterning other) + { + var o = other as DefaultAssemblyReference; + return o != null && shortName == o.shortName; + } + + [Serializable] + sealed class CurrentModuleReference : IModuleReference + { + public IModule Resolve(ITypeResolveContext context) + { + var asm = context.CurrentModule; + if (asm == null) + throw new ArgumentException("A reference to the current assembly cannot be resolved in the compilation's global type resolve context."); + return asm; + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultAttribute.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultAttribute.cs new file mode 100644 index 0000000..9dc0458 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultAttribute.cs @@ -0,0 +1,89 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Immutable; +using System.Linq; +using System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// IAttribute implementation for already-resolved attributes. + /// + public class DefaultAttribute : IAttribute + { + readonly IType attributeType; + volatile IMethod constructor; + + public ImmutableArray> FixedArguments { get; } + public ImmutableArray> NamedArguments { get; } + + public DefaultAttribute(IType attributeType, + ImmutableArray> fixedArguments, + ImmutableArray> namedArguments) + { + if (attributeType == null) + throw new ArgumentNullException(nameof(attributeType)); + this.attributeType = attributeType; + this.FixedArguments = fixedArguments; + this.NamedArguments = namedArguments; + } + + public DefaultAttribute(IMethod constructor, + ImmutableArray> fixedArguments, + ImmutableArray> namedArguments) + { + if (constructor == null) + throw new ArgumentNullException(nameof(constructor)); + this.constructor = constructor; + this.attributeType = constructor.DeclaringType ?? SpecialType.UnknownType; + this.FixedArguments = fixedArguments; + this.NamedArguments = namedArguments; + if (fixedArguments.Length != constructor.Parameters.Count) + { + throw new ArgumentException("Positional argument count must match the constructor's parameter count"); + } + } + + public IType AttributeType { + get { return attributeType; } + } + + bool IAttribute.HasDecodeErrors => false; + + public IMethod Constructor { + get { + var ctor = this.constructor; + if (ctor == null) + { + foreach (var candidate in this.AttributeType.GetConstructors(m => m.Parameters.Count == FixedArguments.Length)) + { + if (candidate.Parameters.Select(p => p.Type).SequenceEqual(this.FixedArguments.Select(a => a.Type))) + { + ctor = candidate; + break; + } + } + this.constructor = ctor; + } + return ctor; + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultParameter.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultParameter.cs new file mode 100644 index 0000000..2fcc5f6 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultParameter.cs @@ -0,0 +1,139 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Text; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Default implementation of . + /// + public sealed class DefaultParameter : IParameter + { + readonly IType type; + readonly string name; + readonly IReadOnlyList attributes; + readonly ReferenceKind referenceKind; + readonly bool isParams, isOptional; + readonly object defaultValue; + readonly IParameterizedMember owner; + + public DefaultParameter(IType type, string name) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + if (name == null) + throw new ArgumentNullException(nameof(name)); + this.type = type; + this.name = name; + this.attributes = EmptyList.Instance; + } + + public DefaultParameter(IType type, string name, IParameterizedMember owner = null, IReadOnlyList attributes = null, + ReferenceKind referenceKind = ReferenceKind.None, bool isParams = false, bool isOptional = false, object defaultValue = null) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + if (name == null) + throw new ArgumentNullException(nameof(name)); + this.type = type; + this.name = name; + this.owner = owner; + this.attributes = attributes ?? EmptyList.Instance; + this.referenceKind = referenceKind; + this.isParams = isParams; + this.isOptional = isOptional; + this.defaultValue = defaultValue; + } + + SymbolKind ISymbol.SymbolKind { + get { return SymbolKind.Parameter; } + } + + public IParameterizedMember Owner { + get { return owner; } + } + + public IEnumerable GetAttributes() => attributes; + + public ReferenceKind ReferenceKind => referenceKind; + public bool IsRef => referenceKind == ReferenceKind.Ref; + public bool IsOut => referenceKind == ReferenceKind.Out; + public bool IsIn => referenceKind == ReferenceKind.In; + + public bool IsParams => isParams; + + public bool IsOptional => isOptional; + + public string Name { + get { return name; } + } + + public IType Type { + get { return type; } + } + + bool IVariable.IsConst { + get { return false; } + } + + public bool HasConstantValueInSignature { + get { return IsOptional; } + } + + public object GetConstantValue(bool throwOnInvalidMetadata) + { + return defaultValue; + } + + public override string ToString() + { + return ToString(this); + } + + public static string ToString(IParameter parameter) + { + var b = new StringBuilder(); + if (parameter.IsRef) + b.Append("ref "); + if (parameter.IsOut) + b.Append("out "); + if (parameter.IsIn) + b.Append("in "); + if (parameter.IsParams) + b.Append("params "); + b.Append(parameter.Name); + b.Append(':'); + b.Append(parameter.Type.ReflectionName); + if (parameter.IsOptional && parameter.HasConstantValueInSignature) + { + b.Append(" = "); + var val = parameter.GetConstantValue(throwOnInvalidMetadata: false); + if (val != null) + b.Append(val.ToString()); + else + b.Append("null"); + } + return b.ToString(); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultTypeParameter.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultTypeParameter.cs new file mode 100644 index 0000000..7de247d --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultTypeParameter.cs @@ -0,0 +1,98 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + public class DefaultTypeParameter : AbstractTypeParameter + { + readonly bool hasValueTypeConstraint; + readonly bool hasReferenceTypeConstraint; + readonly bool hasDefaultConstructorConstraint; + readonly Nullability nullabilityConstraint; + readonly IReadOnlyList attributes; + + public DefaultTypeParameter( + IEntity owner, + int index, string name = null, + VarianceModifier variance = VarianceModifier.Invariant, + IReadOnlyList attributes = null, + bool hasValueTypeConstraint = false, bool hasReferenceTypeConstraint = false, bool hasDefaultConstructorConstraint = false, + IReadOnlyList constraints = null, Nullability nullabilityConstraint = Nullability.Oblivious) + : base(owner, index, name, variance) + { + this.hasValueTypeConstraint = hasValueTypeConstraint; + this.hasReferenceTypeConstraint = hasReferenceTypeConstraint; + this.hasDefaultConstructorConstraint = hasDefaultConstructorConstraint; + this.nullabilityConstraint = nullabilityConstraint; + this.TypeConstraints = MakeConstraints(constraints); + this.attributes = attributes ?? EmptyList.Instance; + } + + public DefaultTypeParameter( + ICompilation compilation, SymbolKind ownerType, + int index, string name = null, + VarianceModifier variance = VarianceModifier.Invariant, + IReadOnlyList attributes = null, + bool hasValueTypeConstraint = false, bool hasReferenceTypeConstraint = false, bool hasDefaultConstructorConstraint = false, + IReadOnlyList constraints = null, Nullability nullabilityConstraint = Nullability.Oblivious) + : base(compilation, ownerType, index, name, variance) + { + this.hasValueTypeConstraint = hasValueTypeConstraint; + this.hasReferenceTypeConstraint = hasReferenceTypeConstraint; + this.hasDefaultConstructorConstraint = hasDefaultConstructorConstraint; + this.nullabilityConstraint = nullabilityConstraint; + this.TypeConstraints = MakeConstraints(constraints); + this.attributes = attributes ?? EmptyList.Instance; + } + + public override IEnumerable GetAttributes() => attributes; + + public override bool HasValueTypeConstraint => hasValueTypeConstraint; + public override bool HasReferenceTypeConstraint => hasReferenceTypeConstraint; + public override bool HasDefaultConstructorConstraint => hasDefaultConstructorConstraint; + public override bool HasUnmanagedConstraint => false; + public override Nullability NullabilityConstraint => nullabilityConstraint; + + public override IReadOnlyList TypeConstraints { get; } + + IReadOnlyList MakeConstraints(IReadOnlyList constraints) + { + var result = new List(); + var hasNonInterfaceConstraint = false; + if (constraints != null) + { + foreach (var c in constraints) + { + result.Add(new TypeConstraint(c)); + if (c.Kind != TypeKind.Interface) + hasNonInterfaceConstraint = true; + } + } + // Do not add the 'System.Object' constraint if there is another constraint with a base class. + if (this.HasValueTypeConstraint || !hasNonInterfaceConstraint) + { + result.Add(new TypeConstraint(this.Compilation.FindType(this.HasValueTypeConstraint ? KnownTypeCode.ValueType : KnownTypeCode.Object))); + } + return result; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultVariable.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultVariable.cs new file mode 100644 index 0000000..c81b8d8 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DefaultVariable.cs @@ -0,0 +1,72 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Default implementation of . + /// + public sealed class DefaultVariable : IVariable + { + readonly string name; + readonly IType type; + readonly object constantValue; + readonly bool isConst; + + public DefaultVariable(IType type, string name) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + if (name == null) + throw new ArgumentNullException(nameof(name)); + this.type = type; + this.name = name; + } + + public DefaultVariable(IType type, string name, + bool isConst = false, object constantValue = null) + : this(type, name) + { + this.isConst = isConst; + this.constantValue = constantValue; + } + + public string Name { + get { return name; } + } + + public IType Type { + get { return type; } + } + + public bool IsConst { + get { return isConst; } + } + + public object GetConstantValue(bool throwOnInvalidMetadata) + { + return constantValue; + } + + public SymbolKind SymbolKind { + get { return SymbolKind.Variable; } + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DummyTypeParameter.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DummyTypeParameter.cs new file mode 100644 index 0000000..a2d301b --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/DummyTypeParameter.cs @@ -0,0 +1,197 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Threading; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + public sealed class DummyTypeParameter : AbstractType, ITypeParameter + { + static ITypeParameter[] methodTypeParameters = { new DummyTypeParameter(SymbolKind.Method, 0) }; + static ITypeParameter[] classTypeParameters = { new DummyTypeParameter(SymbolKind.TypeDefinition, 0) }; + static IReadOnlyList[] classTypeParameterLists = { EmptyList.Instance }; + + public static ITypeParameter GetMethodTypeParameter(int index) + { + return GetTypeParameter(ref methodTypeParameters, SymbolKind.Method, index); + } + + public static ITypeParameter GetClassTypeParameter(int index) + { + return GetTypeParameter(ref classTypeParameters, SymbolKind.TypeDefinition, index); + } + + static ITypeParameter GetTypeParameter(ref ITypeParameter[] typeParameters, SymbolKind symbolKind, int index) + { + var tps = typeParameters; + while (index >= tps.Length) + { + // We don't have a normal type parameter for this index, so we need to extend our array. + // Because the array can be used concurrently from multiple threads, we have to use + // Interlocked.CompareExchange. + var newTps = new ITypeParameter[index + 1]; + tps.CopyTo(newTps, 0); + for (var i = tps.Length; i < newTps.Length; i++) + { + newTps[i] = new DummyTypeParameter(symbolKind, i); + } + var oldTps = Interlocked.CompareExchange(ref typeParameters, newTps, tps); + if (oldTps == tps) + { + // exchange successful + tps = newTps; + } + else + { + // exchange not successful + tps = oldTps; + } + } + return tps[index]; + } + + /// + /// Gets a list filled with dummy type parameters. + /// + internal static IReadOnlyList GetClassTypeParameterList(int length) + { + var tps = classTypeParameterLists; + while (length >= tps.Length) + { + // We don't have a normal type parameter for this index, so we need to extend our array. + // Because the array can be used concurrently from multiple threads, we have to use + // Interlocked.CompareExchange. + var newTps = new IReadOnlyList[length + 1]; + tps.CopyTo(newTps, 0); + for (var i = tps.Length; i < newTps.Length; i++) + { + var newList = new ITypeParameter[i]; + for (var j = 0; j < newList.Length; j++) + { + newList[j] = GetClassTypeParameter(j); + } + newTps[i] = newList; + } + var oldTps = Interlocked.CompareExchange(ref classTypeParameterLists, newTps, tps); + if (oldTps == tps) + { + // exchange successful + tps = newTps; + } + else + { + // exchange not successful + tps = oldTps; + } + } + return tps[length]; + } + + readonly SymbolKind ownerType; + readonly int index; + + private DummyTypeParameter(SymbolKind ownerType, int index) + { + this.ownerType = ownerType; + this.index = index; + } + + SymbolKind ISymbol.SymbolKind { + get { return SymbolKind.TypeParameter; } + } + + public override string Name { + get { + return (ownerType == SymbolKind.Method ? "!!" : "!") + index; + } + } + + public override string ReflectionName { + get { + return (ownerType == SymbolKind.Method ? "``" : "`") + index; + } + } + + public override string ToString() + { + return ReflectionName + " (dummy)"; + } + + public override bool? IsReferenceType { + get { return null; } + } + + public override TypeKind Kind { + get { return TypeKind.TypeParameter; } + } + + public override IType AcceptVisitor(TypeVisitor visitor) + { + return visitor.VisitTypeParameter(this); + } + + public int Index { + get { return index; } + } + + IEnumerable ITypeParameter.GetAttributes() => EmptyList.Instance; + + SymbolKind ITypeParameter.OwnerType { + get { return ownerType; } + } + + VarianceModifier ITypeParameter.Variance { + get { return VarianceModifier.Invariant; } + } + + IEntity ITypeParameter.Owner { + get { return null; } + } + + IType ITypeParameter.EffectiveBaseClass { + get { return SpecialType.UnknownType; } + } + + IReadOnlyCollection ITypeParameter.EffectiveInterfaceSet { + get { return EmptyList.Instance; } + } + + bool ITypeParameter.HasDefaultConstructorConstraint => false; + bool ITypeParameter.HasReferenceTypeConstraint => false; + bool ITypeParameter.HasValueTypeConstraint => false; + bool ITypeParameter.HasUnmanagedConstraint => false; + Nullability ITypeParameter.NullabilityConstraint => Nullability.Oblivious; + + IReadOnlyList ITypeParameter.TypeConstraints => EmptyList.Instance; + + public override IType ChangeNullability(Nullability nullability) + { + if (nullability == Nullability.Oblivious) + { + return this; + } + else + { + return new NullabilityAnnotatedTypeParameter(this, nullability); + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/FakeMember.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/FakeMember.cs new file mode 100644 index 0000000..e1ca453 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/FakeMember.cs @@ -0,0 +1,179 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Reflection; +using System.Reflection.Metadata; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Base class for fake members. + /// + abstract class FakeMember : IMember + { + readonly ICompilation compilation; + + protected FakeMember(ICompilation compilation) + { + this.compilation = compilation ?? throw new ArgumentNullException(nameof(compilation)); + } + + IMember IMember.MemberDefinition => this; + + public IType ReturnType { get; set; } = SpecialType.UnknownType; + + IEnumerable IMember.ExplicitlyImplementedInterfaceMembers => EmptyList.Instance; + + bool IMember.IsExplicitInterfaceImplementation => false; + + bool IMember.IsVirtual => false; + bool IMember.IsOverride => false; + bool IMember.IsOverridable => false; + + TypeParameterSubstitution IMember.Substitution => TypeParameterSubstitution.Identity; + EntityHandle IEntity.MetadataToken => default; + + public string Name { get; set; } + + ITypeDefinition IEntity.DeclaringTypeDefinition => DeclaringType?.GetDefinition(); + + public IType DeclaringType { get; set; } + + IModule IEntity.ParentModule => DeclaringType?.GetDefinition()?.ParentModule; + + IEnumerable IEntity.GetAttributes() => EmptyList.Instance; + + public Accessibility Accessibility { get; set; } = Accessibility.Public; + + public bool IsStatic { get; set; } + bool IEntity.IsAbstract => false; + bool IEntity.IsSealed => false; + + public abstract SymbolKind SymbolKind { get; } + + ICompilation ICompilationProvider.Compilation => compilation; + + string INamedElement.FullName { + get { + if (DeclaringType != null) + return DeclaringType.FullName + "." + Name; + else + return Name; + } + } + + string INamedElement.ReflectionName { + get { + if (DeclaringType != null) + return DeclaringType.ReflectionName + "." + Name; + else + return Name; + } + } + + string INamedElement.Namespace => DeclaringType?.Namespace; + + bool IMember.Equals(IMember obj, TypeVisitor typeNormalization) + { + return Equals(obj); + } + + public abstract IMember Specialize(TypeParameterSubstitution substitution); + } + + class FakeField : FakeMember, IField + { + public FakeField(ICompilation compilation) : base(compilation) + { + } + + bool IField.IsReadOnly => false; + bool IField.IsVolatile => false; + + bool IVariable.IsConst => false; + object IVariable.GetConstantValue(bool throwOnInvalidMetadata) => null; + IType IVariable.Type => ReturnType; + + public override SymbolKind SymbolKind => SymbolKind.Field; + + public override IMember Specialize(TypeParameterSubstitution substitution) + { + return SpecializedField.Create(this, substitution); + } + } + + class FakeMethod : FakeMember, IMethod + { + readonly SymbolKind symbolKind; + + public FakeMethod(ICompilation compilation, SymbolKind symbolKind) : base(compilation) + { + this.symbolKind = symbolKind; + } + + public override SymbolKind SymbolKind => symbolKind; + + IEnumerable IMethod.GetReturnTypeAttributes() => EmptyList.Instance; + bool IMethod.ReturnTypeIsRefReadOnly => false; + bool IMethod.ThisIsRefReadOnly => false; + bool IMethod.IsInitOnly => false; + + public IReadOnlyList TypeParameters { get; set; } = EmptyList.Instance; + + IReadOnlyList IMethod.TypeArguments => TypeParameters; + + bool IMethod.IsExtensionMethod => false; + bool IMethod.IsLocalFunction => false; + bool IMethod.IsConstructor => symbolKind == SymbolKind.Constructor; + bool IMethod.IsDestructor => symbolKind == SymbolKind.Destructor; + bool IMethod.IsOperator => symbolKind == SymbolKind.Operator; + + bool IMethod.HasBody => false; + bool IMethod.IsAccessor => false; + IMember IMethod.AccessorOwner => null; + MethodSemanticsAttributes IMethod.AccessorKind => 0; + + IMethod IMethod.ReducedFrom => null; + + public IReadOnlyList Parameters { get; set; } = EmptyList.Instance; + + public override IMember Specialize(TypeParameterSubstitution substitution) + { + return SpecializedMethod.Create(this, substitution); + } + + IMethod IMethod.Specialize(TypeParameterSubstitution substitution) + { + return SpecializedMethod.Create(this, substitution); + } + + internal static IMethod CreateDummyConstructor(ICompilation compilation, IType declaringType, Accessibility accessibility = Accessibility.Public) + { + return new FakeMethod(compilation, SymbolKind.Constructor) { + DeclaringType = declaringType, + Name = ".ctor", + ReturnType = compilation.FindType(KnownTypeCode.Void), + Accessibility = accessibility, + }; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/GetClassTypeReference.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/GetClassTypeReference.cs new file mode 100644 index 0000000..db60c15 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/GetClassTypeReference.cs @@ -0,0 +1,154 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Type Reference used when the fully qualified type name is known. + /// + [Serializable] + public sealed class GetClassTypeReference : ITypeReference, ISupportsInterning + { + readonly IModuleReference module; + readonly FullTypeName fullTypeName; + readonly bool? isReferenceType; + + /// + /// Creates a new GetClassTypeReference that searches a type definition. + /// + /// The full name of the type. + /// A reference to the module containing this type. + /// If this parameter is null, the GetClassTypeReference will search in all + /// assemblies belonging to the compilation. + /// + public GetClassTypeReference(FullTypeName fullTypeName, IModuleReference module = null, bool? isReferenceType = null) + { + this.fullTypeName = fullTypeName; + this.module = module; + this.isReferenceType = isReferenceType; + } + + /// + /// Creates a new GetClassTypeReference that searches a top-level type in all assemblies. + /// + /// The namespace name containing the type, e.g. "System.Collections.Generic". + /// The name of the type, e.g. "List". + /// The number of type parameters, (e.g. 1 for List<T>). + public GetClassTypeReference(string namespaceName, string name, int typeParameterCount = 0, bool? isReferenceType = null) + { + this.fullTypeName = new TopLevelTypeName(namespaceName, name, typeParameterCount); + this.isReferenceType = isReferenceType; + } + + /// + /// Creates a new GetClassTypeReference that searches a top-level type in the specified assembly. + /// + /// A reference to the assembly containing this type. + /// If this parameter is null, the GetClassTypeReference will search in all assemblies belonging to the ICompilation. + /// The namespace name containing the type, e.g. "System.Collections.Generic". + /// The name of the type, e.g. "List". + /// The number of type parameters, (e.g. 1 for List<T>). + public GetClassTypeReference(IModuleReference module, string namespaceName, string name, int typeParameterCount = 0, bool? isReferenceType = null) + { + this.module = module; + this.fullTypeName = new TopLevelTypeName(namespaceName, name, typeParameterCount); + this.isReferenceType = isReferenceType; + } + + /// + /// Gets the assembly reference. + /// This property returns null if the GetClassTypeReference is searching in all assemblies + /// of the compilation. + /// + public IModuleReference Module { get { return module; } } + + /// + /// Gets the full name of the type this reference is searching for. + /// + public FullTypeName FullTypeName { get { return fullTypeName; } } + + internal static IType ResolveInAllAssemblies(ICompilation compilation, in FullTypeName fullTypeName) + { + foreach (var asm in compilation.Modules) + { + IType type = asm.GetTypeDefinition(fullTypeName); + if (type != null) + return type; + } + return null; + } + + public IType Resolve(ITypeResolveContext context) + { + if (context == null) + throw new ArgumentNullException(nameof(context)); + + IType type = null; + if (module == null) + { + // No assembly specified: look in all assemblies, but prefer the current assembly + if (context.CurrentModule != null) + { + type = context.CurrentModule.GetTypeDefinition(fullTypeName); + } + if (type == null) + { + type = ResolveInAllAssemblies(context.Compilation, in fullTypeName); + } + } + else + { + // Assembly specified: only look in the specified assembly. + // But if that's not loaded in the compilation, allow fall back to other assemblies. + // (the non-loaded assembly might be a facade containing type forwarders - + // for example, when referencing a portable library from a non-portable project) + var asm = module.Resolve(context); + if (asm != null) + { + type = asm.GetTypeDefinition(fullTypeName); + } + else + { + type = ResolveInAllAssemblies(context.Compilation, in fullTypeName); + } + } + return type ?? new UnknownType(fullTypeName, isReferenceType); + } + + public override string ToString() + { + return fullTypeName.ToString() + (module != null ? ", " + module.ToString() : null); + } + + int ISupportsInterning.GetHashCodeForInterning() + { + unchecked + { + return 33 * module.GetHashCode() + fullTypeName.GetHashCode(); + } + } + + bool ISupportsInterning.EqualsForInterning(ISupportsInterning other) + { + var o = other as GetClassTypeReference; + return o != null && module == o.module && fullTypeName == o.fullTypeName && isReferenceType == o.isReferenceType; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/GetMembersHelper.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/GetMembersHelper.cs new file mode 100644 index 0000000..8a2edd5 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/GetMembersHelper.cs @@ -0,0 +1,351 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Provides helper methods for implementing GetMembers() on IType-implementations. + /// Note: GetMembersHelper will recursively call back into IType.GetMembers(), but only with + /// both GetMemberOptions.IgnoreInheritedMembers and GetMemberOptions.ReturnMemberDefinitions set, + /// and only the 'simple' overloads (not taking type arguments). + /// + /// Ensure that your IType implementation does not use the GetMembersHelper if both flags are set, + /// otherwise you'll get a StackOverflowException! + /// + static class GetMembersHelper + { + #region GetNestedTypes + public static IEnumerable GetNestedTypes(IType type, Predicate filter, GetMemberOptions options) + { + return GetNestedTypes(type, null, filter, options); + } + + public static IEnumerable GetNestedTypes(IType type, IReadOnlyList nestedTypeArguments, Predicate filter, GetMemberOptions options) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + return GetNestedTypesImpl(type, nestedTypeArguments, filter, options); + } + else + { + return type.GetNonInterfaceBaseTypes().SelectMany(t => GetNestedTypesImpl(t, nestedTypeArguments, filter, options)); + } + } + + static IEnumerable GetNestedTypesImpl(IType outerType, IReadOnlyList nestedTypeArguments, Predicate filter, GetMemberOptions options) + { + var outerTypeDef = outerType.GetDefinition(); + if (outerTypeDef == null) + yield break; + + var outerTypeParameterCount = outerTypeDef.TypeParameterCount; + var pt = outerType as ParameterizedType; + foreach (var nestedType in outerTypeDef.NestedTypes) + { + var totalTypeParameterCount = nestedType.TypeParameterCount; + if (nestedTypeArguments != null) + { + if (totalTypeParameterCount - outerTypeParameterCount != nestedTypeArguments.Count) + continue; + } + if (!(filter == null || filter(nestedType))) + continue; + + if (totalTypeParameterCount == 0 || (options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) + { + yield return nestedType; + } + else + { + // We need to parameterize the nested type + var newTypeArguments = new IType[totalTypeParameterCount]; + for (var i = 0; i < outerTypeParameterCount; i++) + { + newTypeArguments[i] = pt != null ? pt.GetTypeArgument(i) : outerTypeDef.TypeParameters[i]; + } + for (var i = outerTypeParameterCount; i < totalTypeParameterCount; i++) + { + if (nestedTypeArguments != null) + newTypeArguments[i] = nestedTypeArguments[i - outerTypeParameterCount]; + else + newTypeArguments[i] = SpecialType.UnboundTypeArgument; + } + yield return new ParameterizedType(nestedType, newTypeArguments); + } + } + } + #endregion + + #region GetMethods + public static IEnumerable GetMethods(IType type, Predicate filter, GetMemberOptions options) + { + return GetMethods(type, null, filter, options); + } + + public static IEnumerable GetMethods(IType type, IReadOnlyList typeArguments, Predicate filter, GetMemberOptions options) + { + if (typeArguments != null && typeArguments.Count > 0) + { + filter = FilterTypeParameterCount(typeArguments.Count).And(filter); + } + + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + return GetMethodsImpl(type, typeArguments, filter, options); + } + else + { + return type.GetNonInterfaceBaseTypes().SelectMany(t => GetMethodsImpl(t, typeArguments, filter, options)); + } + } + + static Predicate FilterTypeParameterCount(int expectedTypeParameterCount) + { + return m => m.TypeParameters.Count == expectedTypeParameterCount; + } + + const GetMemberOptions declaredMembers = GetMemberOptions.IgnoreInheritedMembers | GetMemberOptions.ReturnMemberDefinitions; + + static IEnumerable GetMethodsImpl(IType baseType, IReadOnlyList methodTypeArguments, Predicate filter, GetMemberOptions options) + { + var declaredMethods = baseType.GetMethods(filter, options | declaredMembers); + + var pt = baseType as ParameterizedType; + if ((options & GetMemberOptions.ReturnMemberDefinitions) == 0 + && (pt != null || (methodTypeArguments != null && methodTypeArguments.Count > 0))) + { + TypeParameterSubstitution substitution = null; + foreach (var m in declaredMethods) + { + if (methodTypeArguments != null && methodTypeArguments.Count > 0) + { + if (m.TypeParameters.Count != methodTypeArguments.Count) + continue; + } + if (substitution == null) + { + if (pt != null) + substitution = pt.GetSubstitution(methodTypeArguments); + else + substitution = new TypeParameterSubstitution(null, methodTypeArguments); + } + yield return new SpecializedMethod(m, substitution); + } + } + else + { + foreach (var m in declaredMethods) + { + yield return m; + } + } + } + #endregion + + #region GetAccessors + public static IEnumerable GetAccessors(IType type, Predicate filter, GetMemberOptions options) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + return GetAccessorsImpl(type, filter, options); + } + else + { + return type.GetNonInterfaceBaseTypes().SelectMany(t => GetAccessorsImpl(t, filter, options)); + } + } + + static IEnumerable GetAccessorsImpl(IType baseType, Predicate filter, GetMemberOptions options) + { + return GetConstructorsOrAccessorsImpl(baseType, baseType.GetAccessors(filter, options | declaredMembers), options); + } + #endregion + + #region GetConstructors + public static IEnumerable GetConstructors(IType type, Predicate filter, GetMemberOptions options) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + return GetConstructorsImpl(type, filter, options); + } + else + { + return type.GetNonInterfaceBaseTypes().SelectMany(t => GetConstructorsImpl(t, filter, options)); + } + } + + static IEnumerable GetConstructorsImpl(IType baseType, Predicate filter, GetMemberOptions options) + { + return GetConstructorsOrAccessorsImpl(baseType, baseType.GetConstructors(filter, options | declaredMembers), options); + } + + static IEnumerable GetConstructorsOrAccessorsImpl(IType baseType, IEnumerable declaredMembers, GetMemberOptions options) + { + if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) + { + return declaredMembers; + } + + var pt = baseType as ParameterizedType; + if (pt != null) + { + var substitution = pt.GetSubstitution(); + return declaredMembers.Select(m => new SpecializedMethod(m, substitution) { DeclaringType = pt }); + } + else + { + return declaredMembers; + } + } + #endregion + + #region GetProperties + public static IEnumerable GetProperties(IType type, Predicate filter, GetMemberOptions options) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + return GetPropertiesImpl(type, filter, options); + } + else + { + return type.GetNonInterfaceBaseTypes().SelectMany(t => GetPropertiesImpl(t, filter, options)); + } + } + + static IEnumerable GetPropertiesImpl(IType baseType, Predicate filter, GetMemberOptions options) + { + var declaredProperties = baseType.GetProperties(filter, options | declaredMembers); + if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) + { + return declaredProperties; + } + + var pt = baseType as ParameterizedType; + if (pt != null) + { + var substitution = pt.GetSubstitution(); + return declaredProperties.Select(m => new SpecializedProperty(m, substitution) { DeclaringType = pt }); + } + else + { + return declaredProperties; + } + } + #endregion + + #region GetFields + public static IEnumerable GetFields(IType type, Predicate filter, GetMemberOptions options) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + return GetFieldsImpl(type, filter, options); + } + else + { + return type.GetNonInterfaceBaseTypes().SelectMany(t => GetFieldsImpl(t, filter, options)); + } + } + + static IEnumerable GetFieldsImpl(IType baseType, Predicate filter, GetMemberOptions options) + { + var declaredFields = baseType.GetFields(filter, options | declaredMembers); + if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) + { + return declaredFields; + } + + var pt = baseType as ParameterizedType; + if (pt != null) + { + var substitution = pt.GetSubstitution(); + return declaredFields.Select(m => new SpecializedField(m, substitution) { DeclaringType = pt }); + } + else + { + return declaredFields; + } + } + #endregion + + #region GetEvents + public static IEnumerable GetEvents(IType type, Predicate filter, GetMemberOptions options) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + return GetEventsImpl(type, filter, options); + } + else + { + return type.GetNonInterfaceBaseTypes().SelectMany(t => GetEventsImpl(t, filter, options)); + } + } + + static IEnumerable GetEventsImpl(IType baseType, Predicate filter, GetMemberOptions options) + { + var declaredEvents = baseType.GetEvents(filter, options | declaredMembers); + if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) + { + return declaredEvents; + } + + var pt = baseType as ParameterizedType; + if (pt != null) + { + var substitution = pt.GetSubstitution(); + return declaredEvents.Select(m => new SpecializedEvent(m, substitution) { DeclaringType = pt }); + } + else + { + return declaredEvents; + } + } + #endregion + + #region GetMembers + public static IEnumerable GetMembers(IType type, Predicate filter, GetMemberOptions options) + { + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + return GetMembersImpl(type, filter, options); + } + else + { + return type.GetNonInterfaceBaseTypes().SelectMany(t => GetMembersImpl(t, filter, options)); + } + } + + static IEnumerable GetMembersImpl(IType baseType, Predicate filter, GetMemberOptions options) + { + foreach (var m in GetMethodsImpl(baseType, null, filter, options)) + yield return m; + foreach (var m in GetPropertiesImpl(baseType, filter, options)) + yield return m; + foreach (var m in GetFieldsImpl(baseType, filter, options)) + yield return m; + foreach (var m in GetEventsImpl(baseType, filter, options)) + yield return m; + } + #endregion + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/KnownAttributes.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/KnownAttributes.cs new file mode 100644 index 0000000..2b8475d --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/KnownAttributes.cs @@ -0,0 +1,193 @@ +// Copyright (c) 2010-2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Diagnostics; +using System.Linq; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public enum KnownAttribute + { + /// + /// Not a known attribute + /// + None, + + CompilerGenerated, + /// + /// Marks a method as extension method; or a class as containing extension methods. + /// + Extension, + Dynamic, + TupleElementNames, + Nullable, + NullableContext, + NullablePublicOnly, + Conditional, + Obsolete, + IsReadOnly, + DebuggerHidden, + DebuggerStepThrough, + + // Assembly attributes: + AssemblyVersion, + InternalsVisibleTo, + TypeForwardedTo, + ReferenceAssembly, + + // Type attributes: + Serializable, + Flags, + ComImport, + CoClass, + StructLayout, + DefaultMember, + IsByRefLike, + IteratorStateMachine, + AsyncStateMachine, + AsyncMethodBuilder, + AsyncIteratorStateMachine, + + // Field attributes: + FieldOffset, + NonSerialized, + DecimalConstant, + FixedBuffer, + + // Method attributes: + DllImport, + PreserveSig, + MethodImpl, + + // Property attributes: + IndexerName, + + // Parameter attributes: + ParamArray, + In, + Out, + Optional, + CallerMemberName, + CallerFilePath, + CallerLineNumber, + + // Type parameter attributes: + IsUnmanaged, + + // Marshalling attributes: + MarshalAs, + + // Security attributes: + PermissionSet, + + // C# 9 attributes: + NativeInteger, + } + + static class KnownAttributes + { + internal const int Count = (int)KnownAttribute.NativeInteger + 1; + + static readonly TopLevelTypeName[] typeNames = new TopLevelTypeName[Count]{ + default, + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(CompilerGeneratedAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(ExtensionAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(DynamicAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(TupleElementNamesAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", "NullableAttribute"), + new TopLevelTypeName("System.Runtime.CompilerServices", "NullableContextAttribute"), + new TopLevelTypeName("System.Runtime.CompilerServices", "NullablePublicOnlyAttribute"), + new TopLevelTypeName("System.Diagnostics", nameof(ConditionalAttribute)), + new TopLevelTypeName("System", nameof(ObsoleteAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", "IsReadOnlyAttribute"), + new TopLevelTypeName("System.Diagnostics", nameof(DebuggerHiddenAttribute)), + new TopLevelTypeName("System.Diagnostics", nameof(DebuggerStepThroughAttribute)), + // Assembly attributes: + new TopLevelTypeName("System.Reflection", nameof(AssemblyVersionAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(InternalsVisibleToAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(TypeForwardedToAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(ReferenceAssemblyAttribute)), + // Type attributes: + new TopLevelTypeName("System", nameof(SerializableAttribute)), + new TopLevelTypeName("System", nameof(FlagsAttribute)), + new TopLevelTypeName("System.Runtime.InteropServices", nameof(ComImportAttribute)), + new TopLevelTypeName("System.Runtime.InteropServices", nameof(CoClassAttribute)), + new TopLevelTypeName("System.Runtime.InteropServices", nameof(StructLayoutAttribute)), + new TopLevelTypeName("System.Reflection", nameof(DefaultMemberAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", "IsByRefLikeAttribute"), + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(IteratorStateMachineAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(AsyncStateMachineAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", "AsyncMethodBuilderAttribute"), + new TopLevelTypeName("System.Runtime.CompilerServices", "AsyncIteratorStateMachineAttribute"), + // Field attributes: + new TopLevelTypeName("System.Runtime.InteropServices", nameof(FieldOffsetAttribute)), + new TopLevelTypeName("System", nameof(NonSerializedAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(DecimalConstantAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(FixedBufferAttribute)), + // Method attributes: + new TopLevelTypeName("System.Runtime.InteropServices", nameof(DllImportAttribute)), + new TopLevelTypeName("System.Runtime.InteropServices", nameof(PreserveSigAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(MethodImplAttribute)), + // Property attributes: + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(IndexerNameAttribute)), + // Parameter attributes: + new TopLevelTypeName("System", nameof(ParamArrayAttribute)), + new TopLevelTypeName("System.Runtime.InteropServices", nameof(InAttribute)), + new TopLevelTypeName("System.Runtime.InteropServices", nameof(OutAttribute)), + new TopLevelTypeName("System.Runtime.InteropServices", nameof(OptionalAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(CallerMemberNameAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(CallerFilePathAttribute)), + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(CallerLineNumberAttribute)), + // Type parameter attributes: + new TopLevelTypeName("System.Runtime.CompilerServices", "IsUnmanagedAttribute"), + // Marshalling attributes: + new TopLevelTypeName("System.Runtime.InteropServices", nameof(MarshalAsAttribute)), + // Security attributes: + new TopLevelTypeName("System.Security.Permissions", "PermissionSetAttribute"), + // C# 9 attributes: + new TopLevelTypeName("System.Runtime.CompilerServices", "NativeIntegerAttribute"), + }; + + public static ref readonly TopLevelTypeName GetTypeName(this KnownAttribute attr) + { + Debug.Assert(attr != KnownAttribute.None); + return ref typeNames[(int)attr]; + } + + public static IType FindType(this ICompilation compilation, KnownAttribute attrType) + { + return compilation.FindType(attrType.GetTypeName()); + } + + public static KnownAttribute IsKnownAttributeType(this ITypeDefinition attributeType) + { + if (!attributeType.GetNonInterfaceBaseTypes().Any(t => t.IsKnownType(KnownTypeCode.Attribute))) + return KnownAttribute.None; + for (var i = 1; i < typeNames.Length; i++) + { + if (typeNames[i] == attributeType.FullTypeName) + return (KnownAttribute)i; + } + return KnownAttribute.None; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/KnownTypeCache.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/KnownTypeCache.cs new file mode 100644 index 0000000..e600e42 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/KnownTypeCache.cs @@ -0,0 +1,61 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Cache for KnownTypeReferences. + /// + sealed class KnownTypeCache + { + readonly ICompilation compilation; + readonly IType[] knownTypes = new IType[KnownTypeReference.KnownTypeCodeCount]; + + public KnownTypeCache(ICompilation compilation) + { + this.compilation = compilation; + } + + public IType FindType(KnownTypeCode typeCode) + { + var type = LazyInit.VolatileRead(ref knownTypes[(int)typeCode]); + if (type != null) + { + return type; + } + return LazyInit.GetOrSet(ref knownTypes[(int)typeCode], SearchType(typeCode)); + } + + IType SearchType(KnownTypeCode typeCode) + { + var typeRef = KnownTypeReference.Get(typeCode); + if (typeRef == null) + return SpecialType.UnknownType; + var typeName = new TopLevelTypeName(typeRef.Namespace, typeRef.Name, typeRef.TypeParameterCount); + foreach (var asm in compilation.Modules) + { + var typeDef = asm.GetTypeDefinition(typeName); + if (typeDef != null) + return typeDef; + } + return new UnknownType(typeName); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/LocalFunctionMethod.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/LocalFunctionMethod.cs new file mode 100644 index 0000000..240ccae --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/LocalFunctionMethod.cs @@ -0,0 +1,170 @@ +// Copyright (c) 2019 Siegfried Pammer +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// A local function has zero or more compiler-generated parameters added at the end. + /// + class LocalFunctionMethod : IMethod + { + readonly IMethod baseMethod; + + public LocalFunctionMethod(IMethod baseMethod, string name, bool isStaticLocalFunction, int numberOfCompilerGeneratedParameters, int numberOfCompilerGeneratedTypeParameters) + { + if (baseMethod == null) + throw new ArgumentNullException(nameof(baseMethod)); + this.baseMethod = baseMethod; + this.Name = name; + this.IsStaticLocalFunction = isStaticLocalFunction; + this.NumberOfCompilerGeneratedParameters = numberOfCompilerGeneratedParameters; + this.NumberOfCompilerGeneratedTypeParameters = numberOfCompilerGeneratedTypeParameters; + } + + public bool Equals(IMember obj, TypeVisitor typeNormalization) + { + if (!(obj is LocalFunctionMethod other)) + return false; + return baseMethod.Equals(other.baseMethod, typeNormalization) + && NumberOfCompilerGeneratedParameters == other.NumberOfCompilerGeneratedParameters + && NumberOfCompilerGeneratedTypeParameters == other.NumberOfCompilerGeneratedTypeParameters + && IsStaticLocalFunction == other.IsStaticLocalFunction; + } + + public override bool Equals(object obj) + { + if (!(obj is LocalFunctionMethod other)) + return false; + return baseMethod.Equals(other.baseMethod) + && NumberOfCompilerGeneratedParameters == other.NumberOfCompilerGeneratedParameters + && NumberOfCompilerGeneratedTypeParameters == other.NumberOfCompilerGeneratedTypeParameters + && IsStaticLocalFunction == other.IsStaticLocalFunction; + } + + public override int GetHashCode() + { + return baseMethod.GetHashCode(); + } + + public override string ToString() + { + return string.Format("[LocalFunctionMethod: ReducedFrom={0}, Name={1}, NumberOfGeneratedParameters={2}, NumberOfCompilerGeneratedTypeParameters={3}, IsStaticLocalFunction={4}]", ReducedFrom, Name, NumberOfCompilerGeneratedParameters, NumberOfCompilerGeneratedTypeParameters, IsStaticLocalFunction); + } + + internal int NumberOfCompilerGeneratedParameters { get; } + + internal int NumberOfCompilerGeneratedTypeParameters { get; } + + internal bool IsStaticLocalFunction { get; } + + public IMember MemberDefinition => this; + + public IType ReturnType => baseMethod.ReturnType; + IEnumerable IMember.ExplicitlyImplementedInterfaceMembers => baseMethod.ExplicitlyImplementedInterfaceMembers; + bool IMember.IsExplicitInterfaceImplementation => baseMethod.IsExplicitInterfaceImplementation; + public bool IsVirtual => baseMethod.IsVirtual; + public bool IsOverride => baseMethod.IsOverride; + public bool IsOverridable => baseMethod.IsOverridable; + public TypeParameterSubstitution Substitution => baseMethod.Substitution; + + public IMethod Specialize(TypeParameterSubstitution substitution) + { + return new LocalFunctionMethod( + baseMethod.Specialize(substitution), + Name, IsStaticLocalFunction, NumberOfCompilerGeneratedParameters, NumberOfCompilerGeneratedTypeParameters); + } + + IMember IMember.Specialize(TypeParameterSubstitution substitution) + { + return Specialize(substitution); + } + + public bool IsExtensionMethod => baseMethod.IsExtensionMethod; + public bool IsLocalFunction => true; + public bool IsConstructor => baseMethod.IsConstructor; + public bool IsDestructor => baseMethod.IsDestructor; + public bool IsOperator => baseMethod.IsOperator; + public bool HasBody => baseMethod.HasBody; + public bool IsAccessor => baseMethod.IsAccessor; + public IMember AccessorOwner => baseMethod.AccessorOwner; + public MethodSemanticsAttributes AccessorKind => baseMethod.AccessorKind; + public IMethod ReducedFrom => baseMethod; + + List typeParameters; + public IReadOnlyList TypeParameters { + get { + if (typeParameters == null) + typeParameters = new List(baseMethod.TypeParameters.Skip(NumberOfCompilerGeneratedTypeParameters)); + return typeParameters; + } + } + + List typeArguments; + public IReadOnlyList TypeArguments { + get { + if (typeArguments == null) + typeArguments = new List(baseMethod.TypeArguments.Skip(NumberOfCompilerGeneratedTypeParameters)); + return typeArguments; + } + } + + List parameters; + public IReadOnlyList Parameters { + get { + if (parameters == null) + parameters = new List(baseMethod.Parameters.SkipLast(NumberOfCompilerGeneratedParameters)); + return parameters; + } + } + + public System.Reflection.Metadata.EntityHandle MetadataToken => baseMethod.MetadataToken; + public SymbolKind SymbolKind => baseMethod.SymbolKind; + public ITypeDefinition DeclaringTypeDefinition => baseMethod.DeclaringTypeDefinition; + public IType DeclaringType => baseMethod.DeclaringType; + public IModule ParentModule => baseMethod.ParentModule; + IEnumerable IEntity.GetAttributes() => baseMethod.GetAttributes(); + IEnumerable IMethod.GetReturnTypeAttributes() => baseMethod.GetReturnTypeAttributes(); + bool IMethod.ReturnTypeIsRefReadOnly => baseMethod.ReturnTypeIsRefReadOnly; + bool IMethod.ThisIsRefReadOnly => baseMethod.ThisIsRefReadOnly; + bool IMethod.IsInitOnly => baseMethod.IsInitOnly; + /// + /// We consider local functions as always static, because they do not have a "this parameter". + /// Even local functions in instance methods capture this. + /// + public bool IsStatic => true; + public bool IsAbstract => baseMethod.IsAbstract; + public bool IsSealed => baseMethod.IsSealed; + + public Accessibility Accessibility => baseMethod.Accessibility; + + public string FullName => Name; + public string Name { get; set; } + public string ReflectionName => baseMethod.ReflectionName; + public string Namespace => baseMethod.Namespace; + + public ICompilation Compilation => baseMethod.Compilation; + } +} + diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MergedNamespace.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MergedNamespace.cs new file mode 100644 index 0000000..2f6c620 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MergedNamespace.cs @@ -0,0 +1,167 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Linq; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// A merged namespace. + /// + public sealed class MergedNamespace : INamespace + { + readonly string externAlias; + readonly ICompilation compilation; + readonly INamespace parentNamespace; + readonly INamespace[] namespaces; + Dictionary childNamespaces; + + /// + /// Creates a new merged root namespace. + /// + /// The main compilation. + /// The individual namespaces being merged. + /// The extern alias for this namespace. + public MergedNamespace(ICompilation compilation, INamespace[] namespaces, string externAlias = null) + { + if (compilation == null) + throw new ArgumentNullException(nameof(compilation)); + if (namespaces == null) + throw new ArgumentNullException(nameof(namespaces)); + this.compilation = compilation; + this.namespaces = namespaces; + this.externAlias = externAlias; + } + + /// + /// Creates a new merged child namespace. + /// + /// The parent merged namespace. + /// The individual namespaces being merged. + public MergedNamespace(INamespace parentNamespace, INamespace[] namespaces) + { + if (parentNamespace == null) + throw new ArgumentNullException(nameof(parentNamespace)); + if (namespaces == null) + throw new ArgumentNullException(nameof(namespaces)); + this.parentNamespace = parentNamespace; + this.namespaces = namespaces; + this.compilation = parentNamespace.Compilation; + this.externAlias = parentNamespace.ExternAlias; + } + + public string ExternAlias { + get { return externAlias; } + } + + public string FullName { + get { return namespaces[0].FullName; } + } + + public string Name { + get { return namespaces[0].Name; } + } + + public INamespace ParentNamespace { + get { return parentNamespace; } + } + + public IEnumerable Types { + get { + return namespaces.SelectMany(ns => ns.Types); + } + } + + public SymbolKind SymbolKind { + get { return SymbolKind.Namespace; } + } + + public ICompilation Compilation { + get { return compilation; } + } + + public IEnumerable ContributingModules { + get { return namespaces.SelectMany(ns => ns.ContributingModules); } + } + + public IEnumerable ChildNamespaces { + get { return GetChildNamespaces().Values; } + } + + public INamespace GetChildNamespace(string name) + { + INamespace ns; + if (GetChildNamespaces().TryGetValue(name, out ns)) + return ns; + else + return null; + } + + Dictionary GetChildNamespaces() + { + var result = LazyInit.VolatileRead(ref this.childNamespaces); + if (result != null) + { + return result; + } + else + { + result = new Dictionary(compilation.NameComparer); + foreach (var g in namespaces.SelectMany(ns => ns.ChildNamespaces).GroupBy(ns => ns.Name, compilation.NameComparer)) + { + result.Add(g.Key, new MergedNamespace(this, g.ToArray())); + } + return LazyInit.GetOrSet(ref this.childNamespaces, result); + } + } + + public ITypeDefinition GetTypeDefinition(string name, int typeParameterCount) + { + ITypeDefinition anyTypeDef = null; + foreach (var ns in namespaces) + { + var typeDef = ns.GetTypeDefinition(name, typeParameterCount); + if (typeDef != null) + { + if (typeDef.Accessibility == Accessibility.Public) + { + // Prefer accessible types over non-accessible types. + return typeDef; + // || (typeDef.IsInternal && typeDef.ParentAssembly.InternalsVisibleTo(...)) + // We can't call InternalsVisibleTo() here as we don't know the correct 'current' assembly, + // and using the main assembly can cause a stack overflow if there + // are internal assembly attributes. + } + anyTypeDef = typeDef; + } + } + return anyTypeDef; + } + + public override string ToString() + { + return string.Format(CultureInfo.InvariantCulture, "[MergedNamespace {0}{1} (from {2} assemblies)]", + externAlias != null ? externAlias + "::" : null, this.FullName, this.namespaces.Length); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataEvent.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataEvent.cs new file mode 100644 index 0000000..ac43ba4 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataEvent.cs @@ -0,0 +1,154 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + sealed class MetadataEvent : IEvent + { + readonly MetadataModule module; + readonly EventDefinitionHandle handle; + readonly EventAccessors accessors; + readonly string name; + + // lazy-loaded: + IType returnType; + + internal MetadataEvent(MetadataModule module, EventDefinitionHandle handle) + { + Debug.Assert(module != null); + Debug.Assert(!handle.IsNil); + this.module = module; + this.handle = handle; + + var metadata = module.metadata; + var ev = metadata.GetEventDefinition(handle); + accessors = ev.GetAccessors(); + name = metadata.GetString(ev.Name); + } + + public override string ToString() + { + return $"{MetadataTokens.GetToken(handle):X8} {DeclaringType?.ReflectionName}.{Name}"; + } + + public EntityHandle MetadataToken => handle; + public string Name => name; + + SymbolKind ISymbol.SymbolKind => SymbolKind.Event; + + public bool CanAdd => !accessors.Adder.IsNil; + public bool CanRemove => !accessors.Remover.IsNil; + public bool CanInvoke => !accessors.Raiser.IsNil; + public IMethod AddAccessor => module.GetDefinition(accessors.Adder); + public IMethod RemoveAccessor => module.GetDefinition(accessors.Remover); + public IMethod InvokeAccessor => module.GetDefinition(accessors.Raiser); + IMethod AnyAccessor => module.GetDefinition(accessors.GetAny()); + + #region Signature (ReturnType + Parameters) + public IType ReturnType { + get { + var returnType = LazyInit.VolatileRead(ref this.returnType); + if (returnType != null) + return returnType; + var metadata = module.metadata; + var ev = metadata.GetEventDefinition(handle); + var declaringTypeDef = DeclaringTypeDefinition; + var context = new GenericContext(declaringTypeDef?.TypeParameters); + var nullableContext = declaringTypeDef?.NullableContext ?? Nullability.Oblivious; + // The event does not have explicit accessibility in metadata, so use its + // containing type to determine whether nullability applies to this type. + returnType = module.ResolveType(ev.Type, context, ev.GetCustomAttributes(), nullableContext); + return LazyInit.GetOrSet(ref this.returnType, returnType); + } + } + #endregion + + public bool IsExplicitInterfaceImplementation => AnyAccessor?.IsExplicitInterfaceImplementation ?? false; + public IEnumerable ExplicitlyImplementedInterfaceMembers => GetInterfaceMembersFromAccessor(AnyAccessor); + + internal static IEnumerable GetInterfaceMembersFromAccessor(IMethod method) + { + if (method == null) + return EmptyList.Instance; + return method.ExplicitlyImplementedInterfaceMembers.Select(m => ((IMethod)m).AccessorOwner).Where(m => m != null); + } + + public ITypeDefinition DeclaringTypeDefinition => AnyAccessor?.DeclaringTypeDefinition; + public IType DeclaringType => AnyAccessor?.DeclaringType; + IMember IMember.MemberDefinition => this; + TypeParameterSubstitution IMember.Substitution => TypeParameterSubstitution.Identity; + + #region Attributes + public IEnumerable GetAttributes() + { + var b = new AttributeListBuilder(module); + var metadata = module.metadata; + var eventDef = metadata.GetEventDefinition(handle); + b.Add(eventDef.GetCustomAttributes(), SymbolKind.Event); + return b.Build(); + } + #endregion + + public Accessibility Accessibility => AnyAccessor?.Accessibility ?? Accessibility.None; + public bool IsStatic => AnyAccessor?.IsStatic ?? false; + public bool IsAbstract => AnyAccessor?.IsAbstract ?? false; + public bool IsSealed => AnyAccessor?.IsSealed ?? false; + public bool IsVirtual => AnyAccessor?.IsVirtual ?? false; + public bool IsOverride => AnyAccessor?.IsOverride ?? false; + public bool IsOverridable => AnyAccessor?.IsOverridable ?? false; + + public IModule ParentModule => module; + public ICompilation Compilation => module.Compilation; + + public string FullName => $"{DeclaringType?.FullName}.{Name}"; + public string ReflectionName => $"{DeclaringType?.ReflectionName}.{Name}"; + public string Namespace => DeclaringType?.Namespace ?? string.Empty; + + public override bool Equals(object obj) + { + if (obj is MetadataEvent ev) + { + return handle == ev.handle && module.PEFile == ev.module.PEFile; + } + return false; + } + + public override int GetHashCode() + { + return 0x7937039a ^ module.PEFile.GetHashCode() ^ handle.GetHashCode(); + } + + bool IMember.Equals(IMember obj, TypeVisitor typeNormalization) + { + return Equals(obj); + } + + public IMember Specialize(TypeParameterSubstitution substitution) + { + return SpecializedEvent.Create(this, substitution); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataField.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataField.cs new file mode 100644 index 0000000..5754358 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataField.cs @@ -0,0 +1,285 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Threading; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Field definition backed by System.Reflection.Metadata + /// + sealed class MetadataField : IField + { + readonly MetadataModule module; + readonly FieldDefinitionHandle handle; + readonly FieldAttributes attributes; + + // lazy-loaded fields: + ITypeDefinition declaringType; + string name; + object constantValue; + IType type; + bool isVolatile; // initialized together with this.type + // this can't be bool? as bool? is not thread-safe from torn reads + byte decimalConstantState; + + internal MetadataField(MetadataModule module, FieldDefinitionHandle handle) + { + Debug.Assert(module != null); + Debug.Assert(!handle.IsNil); + this.module = module; + this.handle = handle; + var def = module.metadata.GetFieldDefinition(handle); + this.attributes = def.Attributes; + + if ((attributes & (FieldAttributes.Static | FieldAttributes.InitOnly)) != (FieldAttributes.Static | FieldAttributes.InitOnly)) + decimalConstantState = ThreeState.False; + } + + public EntityHandle MetadataToken => handle; + + public override string ToString() + { + return $"{MetadataTokens.GetToken(handle):X8} {DeclaringType?.ReflectionName}.{Name}"; + } + + public string Name { + get { + var name = LazyInit.VolatileRead(ref this.name); + if (name != null) + return name; + var metadata = module.metadata; + var fieldDef = metadata.GetFieldDefinition(handle); + return LazyInit.GetOrSet(ref this.name, metadata.GetString(fieldDef.Name)); + } + } + + public Accessibility Accessibility { + get { + switch (attributes & FieldAttributes.FieldAccessMask) + { + case FieldAttributes.Public: + return Accessibility.Public; + case FieldAttributes.FamANDAssem: + return Accessibility.ProtectedAndInternal; + case FieldAttributes.Assembly: + return Accessibility.Internal; + case FieldAttributes.Family: + return Accessibility.Protected; + case FieldAttributes.FamORAssem: + return Accessibility.ProtectedOrInternal; + default: + return Accessibility.Private; + } + } + } + + public bool IsReadOnly => (attributes & FieldAttributes.InitOnly) != 0; + public bool IsStatic => (attributes & FieldAttributes.Static) != 0; + + SymbolKind ISymbol.SymbolKind => SymbolKind.Field; + IMember IMember.MemberDefinition => this; + TypeParameterSubstitution IMember.Substitution => TypeParameterSubstitution.Identity; + + // Fields can't implement interfaces: + IEnumerable IMember.ExplicitlyImplementedInterfaceMembers => EmptyList.Instance; + bool IMember.IsExplicitInterfaceImplementation => false; + bool IMember.IsVirtual => false; + bool IMember.IsOverride => false; + bool IMember.IsOverridable => false; + bool IEntity.IsAbstract => false; + bool IEntity.IsSealed => false; + + public ITypeDefinition DeclaringTypeDefinition { + get { + var declType = LazyInit.VolatileRead(ref this.declaringType); + if (declType != null) + { + return declType; + } + else + { + var def = module.metadata.GetFieldDefinition(handle); + return LazyInit.GetOrSet(ref this.declaringType, + module.GetDefinition(def.GetDeclaringType())); + } + } + } + + public IType DeclaringType => DeclaringTypeDefinition; + public IModule ParentModule => module; + public ICompilation Compilation => module.Compilation; + + public IEnumerable GetAttributes() + { + var b = new AttributeListBuilder(module); + var metadata = module.metadata; + var fieldDef = metadata.GetFieldDefinition(handle); + + // FieldOffsetAttribute + var offset = fieldDef.GetOffset(); + if (offset != -1) + { + b.Add(KnownAttribute.FieldOffset, KnownTypeCode.Int32, offset); + } + + // NonSerializedAttribute + if ((fieldDef.Attributes & FieldAttributes.NotSerialized) != 0) + { + b.Add(KnownAttribute.NonSerialized); + } + + b.AddMarshalInfo(fieldDef.GetMarshallingDescriptor()); + b.Add(fieldDef.GetCustomAttributes(), SymbolKind.Field); + + return b.Build(); + } + + public string FullName => $"{DeclaringType?.FullName}.{Name}"; + public string ReflectionName => $"{DeclaringType?.ReflectionName}.{Name}"; + public string Namespace => DeclaringType?.Namespace ?? string.Empty; + + public bool IsVolatile { + get { + if (LazyInit.VolatileRead(ref this.type) == null) + { + DecodeTypeAndVolatileFlag(); + } + return this.isVolatile; + } + } + IType IMember.ReturnType => Type; + public IType Type { + get { + var ty = LazyInit.VolatileRead(ref this.type); + if (ty != null) + { + return ty; + } + return DecodeTypeAndVolatileFlag(); + } + } + + private IType DecodeTypeAndVolatileFlag() + { + var metadata = module.metadata; + var fieldDef = metadata.GetFieldDefinition(handle); + IType ty; + try + { + ty = fieldDef.DecodeSignature(module.TypeProvider, new GenericContext(DeclaringType?.TypeParameters)); + if (ty is ModifiedType mod && mod.Modifier.Name == "IsVolatile" && mod.Modifier.Namespace == "System.Runtime.CompilerServices") + { + Volatile.Write(ref this.isVolatile, true); + ty = mod.ElementType; + } + ty = ApplyAttributeTypeVisitor.ApplyAttributesToType(ty, Compilation, + fieldDef.GetCustomAttributes(), metadata, + DeclaringTypeDefinition?.NullableContext ?? Nullability.Oblivious); + } + catch (BadImageFormatException) + { + ty = SpecialType.UnknownType; + } + return LazyInit.GetOrSet(ref this.type, ty); + } + + public bool IsConst => (attributes & FieldAttributes.Literal) != 0 + || (IsDecimalConstant && DecimalConstantHelper.AllowsDecimalConstants(module)); + + bool IsDecimalConstant { + get { + if (decimalConstantState == ThreeState.Unknown) + { + var fieldDef = module.metadata.GetFieldDefinition(handle); + decimalConstantState = ThreeState.From(DecimalConstantHelper.IsDecimalConstant(module, fieldDef.GetCustomAttributes())); + } + return decimalConstantState == ThreeState.True; + } + } + + public object GetConstantValue(bool throwOnInvalidMetadata) + { + var val = LazyInit.VolatileRead(ref this.constantValue); + if (val != null) + return val; + try + { + var metadata = module.metadata; + var fieldDef = metadata.GetFieldDefinition(handle); + if (IsDecimalConstant && DecimalConstantHelper.AllowsDecimalConstants(module)) + { + val = DecimalConstantHelper.GetDecimalConstantValue(module, fieldDef.GetCustomAttributes()); + } + else + { + var constantHandle = fieldDef.GetDefaultValue(); + if (constantHandle.IsNil) + return null; + var constant = metadata.GetConstant(constantHandle); + var blobReader = metadata.GetBlobReader(constant.Value); + try + { + val = blobReader.ReadConstant(constant.TypeCode); + } + catch (ArgumentOutOfRangeException) + { + throw new BadImageFormatException($"Constant with invalid typecode: {constant.TypeCode}"); + } + } + return LazyInit.GetOrSet(ref this.constantValue, val); + } + catch (BadImageFormatException) when (!throwOnInvalidMetadata) + { + return null; + } + } + + public override bool Equals(object obj) + { + if (obj is MetadataField f) + { + return handle == f.handle && module.PEFile == f.module.PEFile; + } + return false; + } + + public override int GetHashCode() + { + return 0x11dda32b ^ module.PEFile.GetHashCode() ^ handle.GetHashCode(); + } + + bool IMember.Equals(IMember obj, TypeVisitor typeNormalization) + { + return Equals(obj); + } + + public IMember Specialize(TypeParameterSubstitution substitution) + { + return SpecializedField.Create(this, substitution); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataMethod.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataMethod.cs new file mode 100644 index 0000000..add7ddb --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataMethod.cs @@ -0,0 +1,595 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + sealed class MetadataMethod : IMethod + { + readonly MetadataModule module; + readonly MethodDefinitionHandle handle; + + // eagerly loaded fields: + readonly MethodAttributes attributes; + readonly SymbolKind symbolKind; + readonly ITypeParameter[] typeParameters; + readonly EntityHandle accessorOwner; + public MethodSemanticsAttributes AccessorKind { get; } + public bool IsExtensionMethod { get; } + bool IMethod.IsLocalFunction => false; + + // lazy-loaded fields: + ITypeDefinition declaringType; + string name; + IParameter[] parameters; + IType returnType; + byte returnTypeIsRefReadonly = ThreeState.Unknown; + byte thisIsRefReadonly = ThreeState.Unknown; + bool isInitOnly; + + internal MetadataMethod(MetadataModule module, MethodDefinitionHandle handle) + { + Debug.Assert(module != null); + Debug.Assert(!handle.IsNil); + this.module = module; + this.handle = handle; + var metadata = module.metadata; + var def = metadata.GetMethodDefinition(handle); + this.attributes = def.Attributes; + + this.symbolKind = SymbolKind.Method; + var (accessorOwner, semanticsAttribute) = module.PEFile.MethodSemanticsLookup.GetSemantics(handle); + const MethodAttributes finalizerAttributes = (MethodAttributes.Virtual | MethodAttributes.Family | MethodAttributes.HideBySig); + if (semanticsAttribute != 0) + { + this.symbolKind = SymbolKind.Accessor; + this.accessorOwner = accessorOwner; + this.AccessorKind = semanticsAttribute; + } + else if ((attributes & (MethodAttributes.SpecialName | MethodAttributes.RTSpecialName)) != 0) + { + var name = this.Name; + if (name == ".cctor" || name == ".ctor") + this.symbolKind = SymbolKind.Constructor; + else if (name.StartsWith("op_", StringComparison.Ordinal)) + this.symbolKind = SymbolKind.Operator; + } + else if ((attributes & finalizerAttributes) == finalizerAttributes) + { + var name = this.Name; + if (name == "Finalize" && Parameters.Count == 0) + { + this.symbolKind = SymbolKind.Destructor; + } + } + this.typeParameters = MetadataTypeParameter.Create(module, this, def.GetGenericParameters()); + this.IsExtensionMethod = (attributes & MethodAttributes.Static) == MethodAttributes.Static + && def.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.Extension); + } + + public EntityHandle MetadataToken => handle; + + public override string ToString() + { + return $"{MetadataTokens.GetToken(handle):X8} {DeclaringType?.ReflectionName}.{Name}"; + } + + public string Name + { + get + { + var name = LazyInit.VolatileRead(ref this.name); + if (name != null) + return name; + var metadata = module.metadata; + var methodDef = metadata.GetMethodDefinition(handle); + return LazyInit.GetOrSet(ref this.name, metadata.GetString(methodDef.Name)); + } + } + + public IReadOnlyList TypeParameters => typeParameters; + IReadOnlyList IMethod.TypeArguments => typeParameters; + + public SymbolKind SymbolKind => symbolKind; + public bool IsConstructor => symbolKind == SymbolKind.Constructor; + public bool IsDestructor => symbolKind == SymbolKind.Destructor; + public bool IsOperator => symbolKind == SymbolKind.Operator; + public bool IsAccessor => symbolKind == SymbolKind.Accessor; + + public bool HasBody => module.metadata.GetMethodDefinition(handle).HasBody(); + + + public IMember AccessorOwner + { + get + { + if (accessorOwner.IsNil) + return null; + if (accessorOwner.Kind == HandleKind.PropertyDefinition) + return module.GetDefinition((PropertyDefinitionHandle)accessorOwner); + else if (accessorOwner.Kind == HandleKind.EventDefinition) + return module.GetDefinition((EventDefinitionHandle)accessorOwner); + else + return null; + } + } + + #region Signature (ReturnType + Parameters) + public IReadOnlyList Parameters + { + get + { + var parameters = LazyInit.VolatileRead(ref this.parameters); + if (parameters != null) + return parameters; + DecodeSignature(); + return this.parameters; + } + } + + public IType ReturnType + { + get + { + var returnType = LazyInit.VolatileRead(ref this.returnType); + if (returnType != null) + return returnType; + DecodeSignature(); + return this.returnType; + } + } + + public bool IsInitOnly + { + get + { + var returnType = LazyInit.VolatileRead(ref this.returnType); + if (returnType == null) + DecodeSignature(); + return this.isInitOnly; + } + } + + internal Nullability NullableContext + { + get + { + var methodDef = module.metadata.GetMethodDefinition(handle); + return methodDef.GetCustomAttributes().GetNullableContext(module.metadata) ?? DeclaringTypeDefinition.NullableContext; + } + } + + private void DecodeSignature() + { + var methodDef = module.metadata.GetMethodDefinition(handle); + var genericContext = new GenericContext(DeclaringType.TypeParameters, this.TypeParameters); + IType returnType; + IParameter[] parameters; + ModifiedType mod; + try + { + var nullableContext = methodDef.GetCustomAttributes().GetNullableContext(module.metadata) ?? DeclaringTypeDefinition.NullableContext; + var signature = methodDef.DecodeSignature(module.TypeProvider, genericContext); + (returnType, parameters, mod) = DecodeSignature(module, this, signature, + methodDef.GetParameters(), nullableContext); + } + catch (BadImageFormatException) + { + returnType = SpecialType.UnknownType; + parameters = Empty.Array; + mod = null; + } + this.isInitOnly = mod is { Modifier: { Name: "IsExternalInit", Namespace: "System.Runtime.CompilerServices" } }; + LazyInit.GetOrSet(ref this.returnType, returnType); + LazyInit.GetOrSet(ref this.parameters, parameters); + } + + internal static (IType returnType, IParameter[] parameters, ModifiedType returnTypeModifier) DecodeSignature( + MetadataModule module, IParameterizedMember owner, + MethodSignature signature, ParameterHandleCollection? parameterHandles, + Nullability nullableContext, + CustomAttributeHandleCollection? returnTypeAttributes = null) + { + var metadata = module.metadata; + var i = 0; + var parameters = new IParameter[signature.RequiredParameterCount + + (signature.Header.CallingConvention == SignatureCallingConvention.VarArgs ? 1 : 0)]; + IType parameterType; + if (parameterHandles != null) + { + foreach (var parameterHandle in parameterHandles) + { + var par = metadata.GetParameter(parameterHandle); + if (par.SequenceNumber == 0) + { + // "parameter" holds return type attributes. + // Note: for properties, the attributes normally stored on a method's return type + // are instead stored as normal attributes on the property. + // So MetadataProperty provides a non-null value for returnTypeAttributes, + // which then should be preferred over the attributes on the accessor's parameters. + if (returnTypeAttributes == null) + { + returnTypeAttributes = par.GetCustomAttributes(); + } + } + else if (par.SequenceNumber > 0 && i < signature.RequiredParameterCount) + { + // "Successive rows of the Param table that are owned by the same method shall be + // ordered by increasing Sequence value - although gaps in the sequence are allowed" + Debug.Assert(i < par.SequenceNumber); + // Fill gaps in the sequence with non-metadata parameters: + while (i < par.SequenceNumber - 1) + { + parameterType = ApplyAttributeTypeVisitor.ApplyAttributesToType( + signature.ParameterTypes[i], module.Compilation, null, metadata, nullableContext); + parameters[i] = new DefaultParameter(parameterType, name: string.Empty, owner, + referenceKind: parameterType.Kind == TypeKind.ByReference ? ReferenceKind.Ref : ReferenceKind.None); + i++; + } + parameterType = ApplyAttributeTypeVisitor.ApplyAttributesToType( + signature.ParameterTypes[i], module.Compilation, + par.GetCustomAttributes(), metadata, nullableContext); + parameters[i] = new MetadataParameter(module, owner, parameterType, parameterHandle); + i++; + } + } + } + while (i < signature.RequiredParameterCount) + { + parameterType = ApplyAttributeTypeVisitor.ApplyAttributesToType( + signature.ParameterTypes[i], module.Compilation, null, metadata, nullableContext); + parameters[i] = new DefaultParameter(parameterType, name: string.Empty, owner, + referenceKind: parameterType.Kind == TypeKind.ByReference ? ReferenceKind.Ref : ReferenceKind.None); + i++; + } + if (signature.Header.CallingConvention == SignatureCallingConvention.VarArgs) + { + parameters[i] = new DefaultParameter(SpecialType.ArgList, name: string.Empty, owner); + i++; + } + Debug.Assert(i == parameters.Length); + var returnType = ApplyAttributeTypeVisitor.ApplyAttributesToType(signature.ReturnType, + module.Compilation, returnTypeAttributes, metadata, nullableContext, + isSignatureReturnType: true); + return (returnType, parameters, signature.ReturnType as ModifiedType); + } + #endregion + + public bool IsExplicitInterfaceImplementation + { + get + { + if (Name.IndexOf('.') < 0) + return false; + var typeDef = ((MetadataTypeDefinition)DeclaringTypeDefinition); + return typeDef.HasOverrides(handle); + } + } + + public IEnumerable ExplicitlyImplementedInterfaceMembers + { + get + { + var typeDef = ((MetadataTypeDefinition)DeclaringTypeDefinition); + return typeDef.GetOverrides(handle); + } + } + + IMember IMember.MemberDefinition => this; + IMethod IMethod.ReducedFrom => null; + TypeParameterSubstitution IMember.Substitution => TypeParameterSubstitution.Identity; + + public ITypeDefinition DeclaringTypeDefinition + { + get + { + var declType = LazyInit.VolatileRead(ref this.declaringType); + if (declType != null) + { + return declType; + } + else + { + var def = module.metadata.GetMethodDefinition(handle); + return LazyInit.GetOrSet(ref this.declaringType, + module.GetDefinition(def.GetDeclaringType())); + } + } + } + + public IType DeclaringType => DeclaringTypeDefinition; + + public IModule ParentModule => module; + public ICompilation Compilation => module.Compilation; + + #region Attributes + IType FindInteropType(string name) + { + return module.Compilation.FindType(new TopLevelTypeName( + "System.Runtime.InteropServices", name, 0 + )); + } + + public IEnumerable GetAttributes() + { + var b = new AttributeListBuilder(module); + + var metadata = module.metadata; + var def = metadata.GetMethodDefinition(handle); + var implAttributes = def.ImplAttributes & ~MethodImplAttributes.CodeTypeMask; + + #region DllImportAttribute + var info = def.GetImport(); + if ((attributes & MethodAttributes.PinvokeImpl) == MethodAttributes.PinvokeImpl && !info.Module.IsNil) + { + var dllImport = new AttributeBuilder(module, KnownAttribute.DllImport); + dllImport.AddFixedArg(KnownTypeCode.String, + metadata.GetString(metadata.GetModuleReference(info.Module).Name)); + + var importAttrs = info.Attributes; + if ((importAttrs & MethodImportAttributes.BestFitMappingDisable) == MethodImportAttributes.BestFitMappingDisable) + dllImport.AddNamedArg("BestFitMapping", KnownTypeCode.Boolean, false); + if ((importAttrs & MethodImportAttributes.BestFitMappingEnable) == MethodImportAttributes.BestFitMappingEnable) + dllImport.AddNamedArg("BestFitMapping", KnownTypeCode.Boolean, true); + + CallingConvention callingConvention; + switch (info.Attributes & MethodImportAttributes.CallingConventionMask) + { + case 0: + Debug.WriteLine($"P/Invoke calling convention not set on: {this}"); + callingConvention = 0; + break; + case MethodImportAttributes.CallingConventionCDecl: + callingConvention = CallingConvention.Cdecl; + break; + case MethodImportAttributes.CallingConventionFastCall: + callingConvention = CallingConvention.FastCall; + break; + case MethodImportAttributes.CallingConventionStdCall: + callingConvention = CallingConvention.StdCall; + break; + case MethodImportAttributes.CallingConventionThisCall: + callingConvention = CallingConvention.ThisCall; + break; + case MethodImportAttributes.CallingConventionWinApi: + callingConvention = CallingConvention.Winapi; + break; + default: + throw new NotSupportedException("unknown calling convention"); + } + if (callingConvention != CallingConvention.Winapi) + { + var callingConventionType = FindInteropType(nameof(CallingConvention)); + dllImport.AddNamedArg("CallingConvention", callingConventionType, (int)callingConvention); + } + + var charSet = CharSet.None; + switch (info.Attributes & MethodImportAttributes.CharSetMask) + { + case MethodImportAttributes.CharSetAnsi: + charSet = CharSet.Ansi; + break; + case MethodImportAttributes.CharSetAuto: + charSet = CharSet.Auto; + break; + case MethodImportAttributes.CharSetUnicode: + charSet = CharSet.Unicode; + break; + } + if (charSet != CharSet.None) + { + var charSetType = FindInteropType(nameof(CharSet)); + dllImport.AddNamedArg("CharSet", charSetType, (int)charSet); + } + + if (!info.Name.IsNil && info.Name != def.Name) + { + dllImport.AddNamedArg("EntryPoint", KnownTypeCode.String, metadata.GetString(info.Name)); + } + + if ((info.Attributes & MethodImportAttributes.ExactSpelling) == MethodImportAttributes.ExactSpelling) + { + dllImport.AddNamedArg("ExactSpelling", KnownTypeCode.Boolean, true); + } + + if ((implAttributes & MethodImplAttributes.PreserveSig) == MethodImplAttributes.PreserveSig) + { + implAttributes &= ~MethodImplAttributes.PreserveSig; + } + else + { + dllImport.AddNamedArg("PreserveSig", KnownTypeCode.Boolean, false); + } + + if ((info.Attributes & MethodImportAttributes.SetLastError) == MethodImportAttributes.SetLastError) + dllImport.AddNamedArg("SetLastError", KnownTypeCode.Boolean, true); + + if ((info.Attributes & MethodImportAttributes.ThrowOnUnmappableCharDisable) == MethodImportAttributes.ThrowOnUnmappableCharDisable) + dllImport.AddNamedArg("ThrowOnUnmappableChar", KnownTypeCode.Boolean, false); + if ((info.Attributes & MethodImportAttributes.ThrowOnUnmappableCharEnable) == MethodImportAttributes.ThrowOnUnmappableCharEnable) + dllImport.AddNamedArg("ThrowOnUnmappableChar", KnownTypeCode.Boolean, true); + + b.Add(dllImport.Build()); + } + #endregion + + #region PreserveSigAttribute + if (implAttributes == MethodImplAttributes.PreserveSig) + { + b.Add(KnownAttribute.PreserveSig); + implAttributes = 0; + } + #endregion + + #region MethodImplAttribute + if (implAttributes != 0) + { + b.Add(KnownAttribute.MethodImpl, + new TopLevelTypeName("System.Runtime.CompilerServices", nameof(MethodImplOptions)), + (int)implAttributes + ); + } + #endregion + + b.Add(def.GetCustomAttributes(), symbolKind); + b.AddSecurityAttributes(def.GetDeclarativeSecurityAttributes()); + + return b.Build(); + } + #endregion + + #region Return type attributes + public IEnumerable GetReturnTypeAttributes() + { + var b = new AttributeListBuilder(module); + var metadata = module.metadata; + var methodDefinition = metadata.GetMethodDefinition(handle); + var parameters = methodDefinition.GetParameters(); + if (parameters.Count > 0) + { + var retParam = metadata.GetParameter(parameters.First()); + if (retParam.SequenceNumber == 0) + { + b.AddMarshalInfo(retParam.GetMarshallingDescriptor()); + b.Add(retParam.GetCustomAttributes(), SymbolKind.ReturnType); + } + } + return b.Build(); + } + + public bool ReturnTypeIsRefReadOnly + { + get + { + if (returnTypeIsRefReadonly != ThreeState.Unknown) + { + return returnTypeIsRefReadonly == ThreeState.True; + } + var metadata = module.metadata; + var methodDefinition = metadata.GetMethodDefinition(handle); + var parameters = methodDefinition.GetParameters(); + var hasReadOnlyAttr = false; + if (parameters.Count > 0) + { + var retParam = metadata.GetParameter(parameters.First()); + if (retParam.SequenceNumber == 0) + { + hasReadOnlyAttr = retParam.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.IsReadOnly); + } + } + this.returnTypeIsRefReadonly = ThreeState.From(hasReadOnlyAttr); + return hasReadOnlyAttr; + } + } + + public bool ThisIsRefReadOnly + { + get + { + if (thisIsRefReadonly != ThreeState.Unknown) + { + return thisIsRefReadonly == ThreeState.True; + } + var metadata = module.metadata; + var methodDefinition = metadata.GetMethodDefinition(handle); + var hasReadOnlyAttr = DeclaringTypeDefinition?.IsReadOnly ?? false; + hasReadOnlyAttr |= methodDefinition.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.IsReadOnly); + this.thisIsRefReadonly = ThreeState.From(hasReadOnlyAttr); + return hasReadOnlyAttr; + } + } + + #endregion + + public Accessibility Accessibility => GetAccessibility(attributes); + + internal static Accessibility GetAccessibility(MethodAttributes attr) + { + switch (attr & MethodAttributes.MemberAccessMask) + { + case MethodAttributes.Public: + return Accessibility.Public; + case MethodAttributes.Assembly: + return Accessibility.Internal; + case MethodAttributes.Private: + return Accessibility.Private; + case MethodAttributes.Family: + return Accessibility.Protected; + case MethodAttributes.FamANDAssem: + return Accessibility.ProtectedAndInternal; + case MethodAttributes.FamORAssem: + return Accessibility.ProtectedOrInternal; + default: + return Accessibility.None; + } + } + + public bool IsStatic => (attributes & MethodAttributes.Static) != 0; + public bool IsAbstract => (attributes & MethodAttributes.Abstract) != 0; + public bool IsSealed => (attributes & (MethodAttributes.Abstract | MethodAttributes.Final | MethodAttributes.NewSlot | MethodAttributes.Static)) == MethodAttributes.Final; + public bool IsVirtual => (attributes & (MethodAttributes.Abstract | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.Final)) == (MethodAttributes.Virtual | MethodAttributes.NewSlot); + public bool IsOverride => (attributes & (MethodAttributes.NewSlot | MethodAttributes.Virtual)) == MethodAttributes.Virtual; + public bool IsOverridable + => (attributes & (MethodAttributes.Abstract | MethodAttributes.Virtual)) != 0 + && (attributes & MethodAttributes.Final) == 0; + + public string FullName => $"{DeclaringType?.FullName}.{Name}"; + public string ReflectionName => $"{DeclaringType?.ReflectionName}.{Name}"; + public string Namespace => DeclaringType?.Namespace ?? string.Empty; + + public override bool Equals(object obj) + { + if (obj is MetadataMethod m) + { + return handle == m.handle && module.PEFile == m.module.PEFile; + } + return false; + } + + public override int GetHashCode() + { + return 0x5a00d671 ^ module.PEFile.GetHashCode() ^ handle.GetHashCode(); + } + + bool IMember.Equals(IMember obj, TypeVisitor typeNormalization) + { + return Equals(obj); + } + + public IMethod Specialize(TypeParameterSubstitution substitution) + { + return SpecializedMethod.Create(this, substitution); + } + + IMember IMember.Specialize(TypeParameterSubstitution substitution) + { + return SpecializedMethod.Create(this, substitution); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataNamespace.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataNamespace.cs new file mode 100644 index 0000000..684d799 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataNamespace.cs @@ -0,0 +1,103 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection.Metadata; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + sealed class MetadataNamespace : INamespace + { + readonly MetadataModule module; + readonly NamespaceDefinition ns; + + public INamespace ParentNamespace { get; } + public string FullName { get; } + public string Name { get; } + + public MetadataNamespace(MetadataModule module, INamespace parent, string fullName, NamespaceDefinition ns) + { + Debug.Assert(module != null); + Debug.Assert(fullName != null); + this.module = module; + this.ParentNamespace = parent; + this.ns = ns; + this.FullName = fullName; + this.Name = module.GetString(ns.Name); + } + + string INamespace.ExternAlias => string.Empty; + + INamespace[] childNamespaces; + + public IEnumerable ChildNamespaces { + get { + var children = LazyInit.VolatileRead(ref childNamespaces); + if (children != null) + { + return children; + } + var nsDefs = ns.NamespaceDefinitions; + children = new INamespace[nsDefs.Length]; + for (var i = 0; i < children.Length; i++) + { + var nsHandle = nsDefs[i]; + var fullName = module.metadata.GetString(nsHandle); + children[i] = new MetadataNamespace(module, this, fullName, + module.metadata.GetNamespaceDefinition(nsHandle)); + } + return LazyInit.GetOrSet(ref childNamespaces, children); + } + } + + IEnumerable INamespace.Types { + get { + foreach (var typeHandle in ns.TypeDefinitions) + { + var def = module.GetDefinition(typeHandle); + if (def != null) + yield return def; + } + } + } + + IEnumerable INamespace.ContributingModules => new[] { module }; + + SymbolKind ISymbol.SymbolKind => SymbolKind.Namespace; + + ICompilation ICompilationProvider.Compilation => module.Compilation; + + INamespace INamespace.GetChildNamespace(string name) + { + foreach (var ns in ChildNamespaces) + { + if (ns.Name == name) + return ns; + } + return null; + } + + ITypeDefinition INamespace.GetTypeDefinition(string name, int typeParameterCount) + { + return module.GetTypeDefinition(FullName, name, typeParameterCount); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataParameter.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataParameter.cs new file mode 100644 index 0000000..00ea302 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataParameter.cs @@ -0,0 +1,203 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + sealed class MetadataParameter : IParameter + { + readonly MetadataModule module; + readonly ParameterHandle handle; + readonly ParameterAttributes attributes; + + public IType Type { get; } + public IParameterizedMember Owner { get; } + + // lazy-loaded: + string name; + // these can't be bool? as bool? is not thread-safe from torn reads + byte constantValueInSignatureState; + byte decimalConstantState; + + internal MetadataParameter(MetadataModule module, IParameterizedMember owner, IType type, ParameterHandle handle) + { + this.module = module; + this.Owner = owner; + this.Type = type; + this.handle = handle; + + var param = module.metadata.GetParameter(handle); + this.attributes = param.Attributes; + if (!IsOptional) + decimalConstantState = ThreeState.False; // only optional parameters can be constants + } + + public EntityHandle MetadataToken => handle; + + #region Attributes + public IEnumerable GetAttributes() + { + var b = new AttributeListBuilder(module); + var metadata = module.metadata; + var parameter = metadata.GetParameter(handle); + + if (IsOptional && !HasConstantValueInSignature) + b.Add(KnownAttribute.Optional); + + if (!IsOut && !IsIn) + { + if ((attributes & ParameterAttributes.In) == ParameterAttributes.In) + b.Add(KnownAttribute.In); + if ((attributes & ParameterAttributes.Out) == ParameterAttributes.Out) + b.Add(KnownAttribute.Out); + } + b.Add(parameter.GetCustomAttributes(), SymbolKind.Parameter); + b.AddMarshalInfo(parameter.GetMarshallingDescriptor()); + + return b.Build(); + } + #endregion + + const ParameterAttributes inOut = ParameterAttributes.In | ParameterAttributes.Out; + + public ReferenceKind ReferenceKind => DetectRefKind(); + public bool IsRef => DetectRefKind() == ReferenceKind.Ref; + public bool IsOut => Type.Kind == TypeKind.ByReference && (attributes & inOut) == ParameterAttributes.Out; + public bool IsIn => DetectRefKind() == ReferenceKind.In; + + public bool IsOptional => (attributes & ParameterAttributes.Optional) != 0; + + ReferenceKind DetectRefKind() + { + if (Type.Kind != TypeKind.ByReference) + return ReferenceKind.None; + if ((attributes & inOut) == ParameterAttributes.Out) + return ReferenceKind.Out; + + var metadata = module.metadata; + var parameterDef = metadata.GetParameter(handle); + if (parameterDef.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.IsReadOnly)) + return ReferenceKind.In; + + return ReferenceKind.Ref; + } + + public bool IsParams + { + get + { + if (Type.Kind != TypeKind.Array) + return false; + var metadata = module.metadata; + var parameterDef = metadata.GetParameter(handle); + return parameterDef.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.ParamArray); + } + } + + public string Name + { + get + { + var name = LazyInit.VolatileRead(ref this.name); + if (name != null) + return name; + var metadata = module.metadata; + var parameterDef = metadata.GetParameter(handle); + return LazyInit.GetOrSet(ref this.name, metadata.GetString(parameterDef.Name)); + } + } + + bool IVariable.IsConst => false; + + public object GetConstantValue(bool throwOnInvalidMetadata) + { + try + { + var metadata = module.metadata; + var parameterDef = metadata.GetParameter(handle); + if (IsDecimalConstant) + return DecimalConstantHelper.GetDecimalConstantValue(module, parameterDef.GetCustomAttributes()); + + var constantHandle = parameterDef.GetDefaultValue(); + if (constantHandle.IsNil) + return null; + + var constant = metadata.GetConstant(constantHandle); + var blobReader = metadata.GetBlobReader(constant.Value); + try + { + return blobReader.ReadConstant(constant.TypeCode); + } + catch (ArgumentOutOfRangeException) + { + throw new BadImageFormatException($"Constant with invalid typecode: {constant.TypeCode}"); + } + } + catch (BadImageFormatException) when (!throwOnInvalidMetadata) + { + return null; + } + } + + public bool HasConstantValueInSignature + { + get + { + if (constantValueInSignatureState == ThreeState.Unknown) + { + if (IsDecimalConstant) + { + constantValueInSignatureState = ThreeState.From(DecimalConstantHelper.AllowsDecimalConstants(module)); + } + else + { + constantValueInSignatureState = ThreeState.From(!module.metadata.GetParameter(handle).GetDefaultValue().IsNil); + } + } + return constantValueInSignatureState == ThreeState.True; + } + } + + bool IsDecimalConstant + { + get + { + if (decimalConstantState == ThreeState.Unknown) + { + var parameterDef = module.metadata.GetParameter(handle); + decimalConstantState = ThreeState.From(DecimalConstantHelper.IsDecimalConstant(module, parameterDef.GetCustomAttributes())); + } + return decimalConstantState == ThreeState.True; + } + } + + SymbolKind ISymbol.SymbolKind => SymbolKind.Parameter; + + public override string ToString() + { + return $"{MetadataTokens.GetToken(handle):X8} {DefaultParameter.ToString(this)}"; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataProperty.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataProperty.cs new file mode 100644 index 0000000..69876ca --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataProperty.cs @@ -0,0 +1,277 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + sealed class MetadataProperty : IProperty + { + const Accessibility InvalidAccessibility = (Accessibility)0xff; + + readonly MetadataModule module; + readonly PropertyDefinitionHandle propertyHandle; + readonly IMethod getter; + readonly IMethod setter; + readonly string name; + readonly SymbolKind symbolKind; + + // lazy-loaded: + volatile Accessibility cachedAccessiblity = InvalidAccessibility; + IParameter[] parameters; + IType returnType; + + internal MetadataProperty(MetadataModule module, PropertyDefinitionHandle handle) + { + Debug.Assert(module != null); + Debug.Assert(!handle.IsNil); + this.module = module; + this.propertyHandle = handle; + + var metadata = module.metadata; + var prop = metadata.GetPropertyDefinition(handle); + var accessors = prop.GetAccessors(); + getter = module.GetDefinition(accessors.Getter); + setter = module.GetDefinition(accessors.Setter); + name = metadata.GetString(prop.Name); + // Maybe we should defer the calculation of symbolKind? + if (DetermineIsIndexer(name)) + { + symbolKind = SymbolKind.Indexer; + } + else if (name.IndexOf('.') >= 0) + { + // explicit interface implementation + var interfaceProp = this.ExplicitlyImplementedInterfaceMembers.FirstOrDefault() as IProperty; + symbolKind = interfaceProp?.SymbolKind ?? SymbolKind.Property; + } + else + { + symbolKind = SymbolKind.Property; + } + } + + bool DetermineIsIndexer(string name) + { + if (name != (DeclaringTypeDefinition as MetadataTypeDefinition)?.DefaultMemberName) + return false; + return Parameters.Count > 0; + } + + public override string ToString() + { + return $"{MetadataTokens.GetToken(propertyHandle):X8} {DeclaringType?.ReflectionName}.{Name}"; + } + + public EntityHandle MetadataToken => propertyHandle; + public string Name => name; + + public bool CanGet => getter != null; + public bool CanSet => setter != null; + + public IMethod Getter => getter; + public IMethod Setter => setter; + IMethod AnyAccessor => getter ?? setter; + + public bool IsIndexer => symbolKind == SymbolKind.Indexer; + public SymbolKind SymbolKind => symbolKind; + + #region Signature (ReturnType + Parameters) + public IReadOnlyList Parameters { + get { + var parameters = LazyInit.VolatileRead(ref this.parameters); + if (parameters != null) + return parameters; + DecodeSignature(); + return this.parameters; + } + } + + public IType ReturnType { + get { + var returnType = LazyInit.VolatileRead(ref this.returnType); + if (returnType != null) + return returnType; + DecodeSignature(); + return this.returnType; + } + } + + public bool ReturnTypeIsRefReadOnly { + get { + var propertyDef = module.metadata.GetPropertyDefinition(propertyHandle); + return propertyDef.GetCustomAttributes().HasKnownAttribute(module.metadata, KnownAttribute.IsReadOnly); + } + } + + private void DecodeSignature() + { + var propertyDef = module.metadata.GetPropertyDefinition(propertyHandle); + var genericContext = new GenericContext(DeclaringType.TypeParameters); + IType returnType; + IParameter[] parameters; + try + { + var signature = propertyDef.DecodeSignature(module.TypeProvider, genericContext); + var accessors = propertyDef.GetAccessors(); + var declTypeDef = this.DeclaringTypeDefinition; + ParameterHandleCollection? parameterHandles; + Nullability nullableContext; + if (!accessors.Getter.IsNil) + { + var getter = module.metadata.GetMethodDefinition(accessors.Getter); + parameterHandles = getter.GetParameters(); + nullableContext = getter.GetCustomAttributes().GetNullableContext(module.metadata) + ?? declTypeDef?.NullableContext ?? Nullability.Oblivious; + } + else if (!accessors.Setter.IsNil) + { + var setter = module.metadata.GetMethodDefinition(accessors.Setter); + parameterHandles = setter.GetParameters(); + nullableContext = setter.GetCustomAttributes().GetNullableContext(module.metadata) + ?? declTypeDef?.NullableContext ?? Nullability.Oblivious; + } + else + { + parameterHandles = null; + nullableContext = declTypeDef?.NullableContext ?? Nullability.Oblivious; + } + // We call OptionsForEntity() for the declaring type, not the property itself, + // because the property's accessibilty isn't stored in metadata but computed. + // Otherwise we'd get infinite recursion, because computing the accessibility + // requires decoding the signature for the GetBaseMembers() call. + // Roslyn uses the same workaround (see the NullableTypeDecoder.TransformType + // call in PEPropertySymbol). + (returnType, parameters, _) = MetadataMethod.DecodeSignature( + module, this, signature, + parameterHandles, nullableContext, + returnTypeAttributes: propertyDef.GetCustomAttributes()); + } + catch (BadImageFormatException) + { + returnType = SpecialType.UnknownType; + parameters = Empty.Array; + } + LazyInit.GetOrSet(ref this.returnType, returnType); + LazyInit.GetOrSet(ref this.parameters, parameters); + } + #endregion + + public bool IsExplicitInterfaceImplementation => AnyAccessor?.IsExplicitInterfaceImplementation ?? false; + public IEnumerable ExplicitlyImplementedInterfaceMembers => GetInterfaceMembersFromAccessor(AnyAccessor); + + internal static IEnumerable GetInterfaceMembersFromAccessor(IMethod method) + { + if (method == null) + return EmptyList.Instance; + return method.ExplicitlyImplementedInterfaceMembers.Select(m => ((IMethod)m).AccessorOwner).Where(m => m != null); + } + + public ITypeDefinition DeclaringTypeDefinition => AnyAccessor?.DeclaringTypeDefinition; + public IType DeclaringType => AnyAccessor?.DeclaringType; + IMember IMember.MemberDefinition => this; + TypeParameterSubstitution IMember.Substitution => TypeParameterSubstitution.Identity; + + #region Attributes + public IEnumerable GetAttributes() + { + var b = new AttributeListBuilder(module); + var metadata = module.metadata; + var propertyDef = metadata.GetPropertyDefinition(propertyHandle); + if (IsIndexer && Name != "Item" && !IsExplicitInterfaceImplementation) + { + b.Add(KnownAttribute.IndexerName, KnownTypeCode.String, Name); + } + b.Add(propertyDef.GetCustomAttributes(), symbolKind); + return b.Build(); + } + #endregion + + #region Accessibility + public Accessibility Accessibility { + get { + var acc = cachedAccessiblity; + if (acc == InvalidAccessibility) + return cachedAccessiblity = ComputeAccessibility(); + else + return acc; + } + } + + Accessibility ComputeAccessibility() + { + if (IsOverride && (getter == null || setter == null)) + { + foreach (var baseMember in InheritanceHelper.GetBaseMembers(this, includeImplementedInterfaces: false)) + { + if (!baseMember.IsOverride) + return baseMember.Accessibility; + } + } + return AccessibilityExtensions.Union( + this.Getter?.Accessibility ?? Accessibility.None, + this.Setter?.Accessibility ?? Accessibility.None); + } + #endregion + + public bool IsStatic => AnyAccessor?.IsStatic ?? false; + public bool IsAbstract => AnyAccessor?.IsAbstract ?? false; + public bool IsSealed => AnyAccessor?.IsSealed ?? false; + public bool IsVirtual => AnyAccessor?.IsVirtual ?? false; + public bool IsOverride => AnyAccessor?.IsOverride ?? false; + public bool IsOverridable => AnyAccessor?.IsOverridable ?? false; + + public IModule ParentModule => module; + public ICompilation Compilation => module.Compilation; + + public string FullName => $"{DeclaringType?.FullName}.{Name}"; + public string ReflectionName => $"{DeclaringType?.ReflectionName}.{Name}"; + public string Namespace => DeclaringType?.Namespace ?? string.Empty; + + public override bool Equals(object obj) + { + if (obj is MetadataProperty p) + { + return propertyHandle == p.propertyHandle && module.PEFile == p.module.PEFile; + } + return false; + } + + public override int GetHashCode() + { + return 0x32b6a76c ^ module.PEFile.GetHashCode() ^ propertyHandle.GetHashCode(); + } + + bool IMember.Equals(IMember obj, TypeVisitor typeNormalization) + { + return Equals(obj); + } + + public IMember Specialize(TypeParameterSubstitution substitution) + { + return SpecializedProperty.Create(this, substitution); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataTypeDefinition.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataTypeDefinition.cs new file mode 100644 index 0000000..c7e8799 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataTypeDefinition.cs @@ -0,0 +1,730 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; +using System.Runtime.InteropServices; + +using ICSharpCode.Decompiler.Metadata; +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Type definition backed by System.Reflection.Metadata + /// + sealed class MetadataTypeDefinition : ITypeDefinition + { + readonly MetadataModule module; + readonly TypeDefinitionHandle handle; + + // eagerly loaded: + readonly FullTypeName fullTypeName; + readonly TypeAttributes attributes; + public TypeKind Kind { get; } + public bool IsByRefLike { get; } + public bool IsReadOnly { get; } + public ITypeDefinition DeclaringTypeDefinition { get; } + public IReadOnlyList TypeParameters { get; } + public KnownTypeCode KnownTypeCode { get; } + public IType EnumUnderlyingType { get; } + public bool HasExtensionMethods { get; } + public Nullability NullableContext { get; } + + // lazy-loaded: + IMember[] members; + IField[] fields; + IProperty[] properties; + IEvent[] events; + IMethod[] methods; + List directBaseTypes; + string defaultMemberName; + + internal MetadataTypeDefinition(MetadataModule module, TypeDefinitionHandle handle) + { + Debug.Assert(module != null); + Debug.Assert(!handle.IsNil); + this.module = module; + this.handle = handle; + var metadata = module.metadata; + var td = metadata.GetTypeDefinition(handle); + this.attributes = td.Attributes; + this.fullTypeName = td.GetFullTypeName(metadata); + // Find DeclaringType + KnownTypeCode: + if (fullTypeName.IsNested) + { + this.DeclaringTypeDefinition = module.GetDefinition(td.GetDeclaringType()); + + // Create type parameters: + this.TypeParameters = MetadataTypeParameter.Create(module, this.DeclaringTypeDefinition, this, td.GetGenericParameters()); + + this.NullableContext = td.GetCustomAttributes().GetNullableContext(metadata) ?? this.DeclaringTypeDefinition.NullableContext; + } + else + { + // Create type parameters: + this.TypeParameters = MetadataTypeParameter.Create(module, this, td.GetGenericParameters()); + + this.NullableContext = td.GetCustomAttributes().GetNullableContext(metadata) ?? module.NullableContext; + + var topLevelTypeName = fullTypeName.TopLevelTypeName; + for (var i = 0; i < KnownTypeReference.KnownTypeCodeCount; i++) + { + var ktr = KnownTypeReference.Get((KnownTypeCode)i); + if (ktr != null && ktr.TypeName == topLevelTypeName) + { + this.KnownTypeCode = (KnownTypeCode)i; + break; + } + } + } + // Find type kind: + if ((attributes & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface) + { + this.Kind = TypeKind.Interface; + } + else if (td.IsEnum(metadata, out var underlyingType)) + { + this.Kind = TypeKind.Enum; + this.EnumUnderlyingType = module.Compilation.FindType(underlyingType.ToKnownTypeCode()); + } + else if (td.IsValueType(metadata)) + { + if (KnownTypeCode == KnownTypeCode.Void) + { + this.Kind = TypeKind.Void; + } + else + { + this.Kind = TypeKind.Struct; + this.IsByRefLike = td.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.IsByRefLike); + this.IsReadOnly = td.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.IsReadOnly); + } + } + else if (td.IsDelegate(metadata)) + { + this.Kind = TypeKind.Delegate; + } + else + { + this.Kind = TypeKind.Class; + this.HasExtensionMethods = this.IsStatic + && td.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.Extension); + } + } + + public override string ToString() + { + return $"{MetadataTokens.GetToken(handle):X8} {fullTypeName}"; + } + + ITypeDefinition[] nestedTypes; + + public IReadOnlyList NestedTypes { + get { + var nestedTypes = LazyInit.VolatileRead(ref this.nestedTypes); + if (nestedTypes != null) + return nestedTypes; + var metadata = module.metadata; + var nestedTypeCollection = metadata.GetTypeDefinition(handle).GetNestedTypes(); + var nestedTypeList = new List(nestedTypeCollection.Length); + foreach (var h in nestedTypeCollection) + { + nestedTypeList.Add(module.GetDefinition(h)); + } + + return LazyInit.GetOrSet(ref this.nestedTypes, nestedTypeList.ToArray()); + } + } + + #region Members + public IReadOnlyList Members { + get { + var members = LazyInit.VolatileRead(ref this.members); + if (members != null) + return members; + members = this.Fields.Concat(this.Methods).Concat(this.Properties).Concat(this.Events).ToArray(); + + return LazyInit.GetOrSet(ref this.members, members); + } + } + + public IEnumerable Fields { + get { + var fields = LazyInit.VolatileRead(ref this.fields); + if (fields != null) + return fields; + var metadata = module.metadata; + var fieldCollection = metadata.GetTypeDefinition(handle).GetFields(); + var fieldList = new List(fieldCollection.Count); + foreach (var h in fieldCollection) + { + var field = metadata.GetFieldDefinition(h); + var attr = field.Attributes; + if (module.IsVisible(attr)) + { + fieldList.Add(module.GetDefinition(h)); + } + } + + return LazyInit.GetOrSet(ref this.fields, fieldList.ToArray()); + } + } + + public IEnumerable Properties { + get { + var properties = LazyInit.VolatileRead(ref this.properties); + if (properties != null) + return properties; + var metadata = module.metadata; + var propertyCollection = metadata.GetTypeDefinition(handle).GetProperties(); + var propertyList = new List(propertyCollection.Count); + foreach (var h in propertyCollection) + { + var property = metadata.GetPropertyDefinition(h); + var accessors = property.GetAccessors(); + var getterVisible = !accessors.Getter.IsNil && module.IsVisible(metadata.GetMethodDefinition(accessors.Getter).Attributes); + var setterVisible = !accessors.Setter.IsNil && module.IsVisible(metadata.GetMethodDefinition(accessors.Setter).Attributes); + if (getterVisible || setterVisible) + { + propertyList.Add(module.GetDefinition(h)); + } + } + + return LazyInit.GetOrSet(ref this.properties, propertyList.ToArray()); + } + } + + public IEnumerable Events { + get { + var events = LazyInit.VolatileRead(ref this.events); + if (events != null) + return events; + var metadata = module.metadata; + var eventCollection = metadata.GetTypeDefinition(handle).GetEvents(); + var eventList = new List(eventCollection.Count); + foreach (var h in eventCollection) + { + var ev = metadata.GetEventDefinition(h); + var accessors = ev.GetAccessors(); + if (accessors.Adder.IsNil) + continue; + var addMethod = metadata.GetMethodDefinition(accessors.Adder); + if (module.IsVisible(addMethod.Attributes)) + { + eventList.Add(module.GetDefinition(h)); + } + } + + return LazyInit.GetOrSet(ref this.events, eventList.ToArray()); + } + } + + public IEnumerable Methods { + get { + var methods = LazyInit.VolatileRead(ref this.methods); + if (methods != null) + return methods; + var metadata = module.metadata; + var methodsCollection = metadata.GetTypeDefinition(handle).GetMethods(); + var methodsList = new List(methodsCollection.Count); + var methodSemantics = module.PEFile.MethodSemanticsLookup; + foreach (var h in methodsCollection) + { + var md = metadata.GetMethodDefinition(h); + if (methodSemantics.GetSemantics(h).Item2 == 0 && module.IsVisible(md.Attributes)) + { + methodsList.Add(module.GetDefinition(h)); + } + } + if (this.Kind == TypeKind.Struct || this.Kind == TypeKind.Enum) + { + methodsList.Add(FakeMethod.CreateDummyConstructor(Compilation, this, IsAbstract ? Accessibility.Protected : Accessibility.Public)); + } + + return LazyInit.GetOrSet(ref this.methods, methodsList.ToArray()); + } + } + #endregion + + public IType DeclaringType => DeclaringTypeDefinition; + + public bool? IsReferenceType { + get { + switch (Kind) + { + case TypeKind.Struct: + case TypeKind.Enum: + case TypeKind.Void: + return false; + default: + return true; + } + } + } + + public int TypeParameterCount => TypeParameters.Count; + + IReadOnlyList IType.TypeArguments => TypeParameters; + + Nullability IType.Nullability => Nullability.Oblivious; + + public IType ChangeNullability(Nullability nullability) + { + if (nullability == Nullability.Oblivious) + return this; + else + return new NullabilityAnnotatedType(this, nullability); + } + + public IEnumerable DirectBaseTypes { + get { + var baseTypes = LazyInit.VolatileRead(ref this.directBaseTypes); + if (baseTypes != null) + return baseTypes; + var metadata = module.metadata; + var td = metadata.GetTypeDefinition(handle); + var context = new GenericContext(TypeParameters); + var interfaceImplCollection = td.GetInterfaceImplementations(); + baseTypes = new List(1 + interfaceImplCollection.Count); + IType baseType = null; + try + { + var baseTypeHandle = td.BaseType; + if (!baseTypeHandle.IsNil) + { + baseType = module.ResolveType(baseTypeHandle, context); + } + } + catch (BadImageFormatException) + { + baseType = SpecialType.UnknownType; + } + if (baseType != null) + { + baseTypes.Add(baseType); + } + else if (Kind == TypeKind.Interface) + { + // td.BaseType.IsNil is always true for interfaces, + // but the type system expects every interface to derive from System.Object as well. + baseTypes.Add(Compilation.FindType(KnownTypeCode.Object)); + } + foreach (var h in interfaceImplCollection) + { + var iface = metadata.GetInterfaceImplementation(h); + baseTypes.Add(module.ResolveType(iface.Interface, context, iface.GetCustomAttributes(), Nullability.Oblivious)); + } + return LazyInit.GetOrSet(ref this.directBaseTypes, baseTypes); + } + } + + public EntityHandle MetadataToken => handle; + + public FullTypeName FullTypeName => fullTypeName; + public string Name => fullTypeName.Name; + + public IModule ParentModule => module; + + #region Type Attributes + public IEnumerable GetAttributes() + { + var b = new AttributeListBuilder(module); + var metadata = module.metadata; + var typeDefinition = metadata.GetTypeDefinition(handle); + + // SerializableAttribute + if ((typeDefinition.Attributes & TypeAttributes.Serializable) != 0) + b.Add(KnownAttribute.Serializable); + + // ComImportAttribute + if ((typeDefinition.Attributes & TypeAttributes.Import) != 0) + b.Add(KnownAttribute.ComImport); + + #region StructLayoutAttribute + var layoutKind = LayoutKind.Auto; + switch (typeDefinition.Attributes & TypeAttributes.LayoutMask) + { + case TypeAttributes.SequentialLayout: + layoutKind = LayoutKind.Sequential; + break; + case TypeAttributes.ExplicitLayout: + layoutKind = LayoutKind.Explicit; + break; + } + var charSet = CharSet.None; + switch (typeDefinition.Attributes & TypeAttributes.StringFormatMask) + { + case TypeAttributes.AnsiClass: + charSet = CharSet.Ansi; + break; + case TypeAttributes.AutoClass: + charSet = CharSet.Auto; + break; + case TypeAttributes.UnicodeClass: + charSet = CharSet.Unicode; + break; + } + var layout = typeDefinition.GetLayout(); + var defaultLayoutKind = Kind == TypeKind.Struct ? LayoutKind.Sequential : LayoutKind.Auto; + if (layoutKind != defaultLayoutKind || charSet != CharSet.Ansi || layout.PackingSize > 0 || layout.Size > 0) + { + var structLayout = new AttributeBuilder(module, KnownAttribute.StructLayout); + structLayout.AddFixedArg( + new TopLevelTypeName("System.Runtime.InteropServices", "LayoutKind"), + (int)layoutKind); + if (charSet != CharSet.Ansi) + { + var charSetType = Compilation.FindType(new TopLevelTypeName("System.Runtime.InteropServices", "CharSet")); + structLayout.AddNamedArg("CharSet", charSetType, (int)charSet); + } + if (layout.PackingSize > 0) + { + structLayout.AddNamedArg("Pack", KnownTypeCode.Int32, (int)layout.PackingSize); + } + if (layout.Size > 0) + { + structLayout.AddNamedArg("Size", KnownTypeCode.Int32, (int)layout.Size); + } + b.Add(structLayout.Build()); + } + #endregion + + b.Add(typeDefinition.GetCustomAttributes(), SymbolKind.TypeDefinition); + b.AddSecurityAttributes(typeDefinition.GetDeclarativeSecurityAttributes()); + + return b.Build(); + } + + public string DefaultMemberName { + get { + var defaultMemberName = LazyInit.VolatileRead(ref this.defaultMemberName); + if (defaultMemberName != null) + return defaultMemberName; + var metadata = module.metadata; + var typeDefinition = metadata.GetTypeDefinition(handle); + foreach (var h in typeDefinition.GetCustomAttributes()) + { + var a = metadata.GetCustomAttribute(h); + if (!a.IsKnownAttribute(metadata, KnownAttribute.DefaultMember)) + continue; + var value = a.DecodeValue(module.TypeProvider); + if (value.FixedArguments.Length == 1 && value.FixedArguments[0].Value is string name) + { + defaultMemberName = name; + break; + } + } + return LazyInit.GetOrSet(ref this.defaultMemberName, defaultMemberName ?? "Item"); + } + } + #endregion + + public Accessibility Accessibility { + get { + switch (attributes & TypeAttributes.VisibilityMask) + { + case TypeAttributes.NotPublic: + case TypeAttributes.NestedAssembly: + return Accessibility.Internal; + case TypeAttributes.Public: + case TypeAttributes.NestedPublic: + return Accessibility.Public; + case TypeAttributes.NestedPrivate: + return Accessibility.Private; + case TypeAttributes.NestedFamily: + return Accessibility.Protected; + case TypeAttributes.NestedFamANDAssem: + return Accessibility.ProtectedAndInternal; + case TypeAttributes.NestedFamORAssem: + return Accessibility.ProtectedOrInternal; + default: + return Accessibility.None; + } + } + } + + public bool IsStatic => (attributes & (TypeAttributes.Abstract | TypeAttributes.Sealed)) == (TypeAttributes.Abstract | TypeAttributes.Sealed); + public bool IsAbstract => (attributes & TypeAttributes.Abstract) != 0; + public bool IsSealed => (attributes & TypeAttributes.Sealed) != 0; + + public SymbolKind SymbolKind => SymbolKind.TypeDefinition; + + public ICompilation Compilation => module.Compilation; + + public string FullName { + get { + if (DeclaringType != null) + return DeclaringType.FullName + "." + Name; + else if (!string.IsNullOrEmpty(this.Namespace)) + return this.Namespace + "." + Name; + else + return Name; + } + } + + public string ReflectionName => fullTypeName.ReflectionName; + public string Namespace => fullTypeName.TopLevelTypeName.Namespace; + + ITypeDefinition IType.GetDefinition() => this; + TypeParameterSubstitution IType.GetSubstitution() => TypeParameterSubstitution.Identity; + + public IType AcceptVisitor(TypeVisitor visitor) + { + return visitor.VisitTypeDefinition(this); + } + + IType IType.VisitChildren(TypeVisitor visitor) + { + return this; + } + + public override bool Equals(object obj) + { + if (obj is MetadataTypeDefinition td) + { + return handle == td.handle && module.PEFile == td.module.PEFile; + } + return false; + } + + public override int GetHashCode() + { + return 0x2e0520f2 ^ module.PEFile.GetHashCode() ^ handle.GetHashCode(); + } + + bool IEquatable.Equals(IType other) + { + return Equals(other); + } + + #region GetNestedTypes + public IEnumerable GetNestedTypes(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + const GetMemberOptions opt = GetMemberOptions.IgnoreInheritedMembers | GetMemberOptions.ReturnMemberDefinitions; + if ((options & opt) == opt) + { + return GetFiltered(this.NestedTypes, filter); + } + else + { + return GetMembersHelper.GetNestedTypes(this, filter, options); + } + } + + public IEnumerable GetNestedTypes(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return GetMembersHelper.GetNestedTypes(this, typeArguments, filter, options); + } + #endregion + + #region GetMembers() + IEnumerable GetFiltered(IEnumerable input, Predicate filter) where T : class + { + if (filter == null) + return input; + else + return ApplyFilter(input, filter); + } + + IEnumerable ApplyFilter(IEnumerable input, Predicate filter) where T : class + { + foreach (var member in input) + { + if (filter(member)) + yield return member; + } + } + + public IEnumerable GetMethods(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if (Kind == TypeKind.Void) + return EmptyList.Instance; + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + return GetFiltered(this.Methods, ExtensionMethods.And(m => !m.IsConstructor, filter)); + } + else + { + return GetMembersHelper.GetMethods(this, filter, options); + } + } + + public IEnumerable GetMethods(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if (Kind == TypeKind.Void) + return EmptyList.Instance; + return GetMembersHelper.GetMethods(this, typeArguments, filter, options); + } + + public IEnumerable GetConstructors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.IgnoreInheritedMembers) + { + if (Kind == TypeKind.Void) + return EmptyList.Instance; + if (ComHelper.IsComImport(this)) + { + var coClass = ComHelper.GetCoClass(this); + using (var busyLock = BusyManager.Enter(this)) + { + if (busyLock.Success) + { + return coClass.GetConstructors(filter, options) + .Select(m => new SpecializedMethod(m, m.Substitution) { DeclaringType = this }); + } + } + return EmptyList.Instance; + } + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + return GetFiltered(this.Methods, ExtensionMethods.And(m => m.IsConstructor && !m.IsStatic, filter)); + } + else + { + return GetMembersHelper.GetConstructors(this, filter, options); + } + } + + public IEnumerable GetProperties(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if (Kind == TypeKind.Void) + return EmptyList.Instance; + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + return GetFiltered(this.Properties, filter); + } + else + { + return GetMembersHelper.GetProperties(this, filter, options); + } + } + + public IEnumerable GetFields(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if (Kind == TypeKind.Void) + return EmptyList.Instance; + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + return GetFiltered(this.Fields, filter); + } + else + { + return GetMembersHelper.GetFields(this, filter, options); + } + } + + public IEnumerable GetEvents(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if (Kind == TypeKind.Void) + return EmptyList.Instance; + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + return GetFiltered(this.Events, filter); + } + else + { + return GetMembersHelper.GetEvents(this, filter, options); + } + } + + public IEnumerable GetMembers(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if (Kind == TypeKind.Void) + return EmptyList.Instance; + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + return GetFiltered(this.Members, filter); + } + else + { + return GetMembersHelper.GetMembers(this, filter, options); + } + } + + public IEnumerable GetAccessors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if (Kind == TypeKind.Void) + return EmptyList.Instance; + if ((options & GetMemberOptions.IgnoreInheritedMembers) == GetMemberOptions.IgnoreInheritedMembers) + { + return GetFilteredAccessors(filter); + } + else + { + return GetMembersHelper.GetAccessors(this, filter, options); + } + } + + IEnumerable GetFilteredAccessors(Predicate filter) + { + foreach (var prop in this.Properties) + { + var getter = prop.Getter; + if (getter != null && (filter == null || filter(getter))) + yield return getter; + var setter = prop.Setter; + if (setter != null && (filter == null || filter(setter))) + yield return setter; + } + foreach (var ev in this.Events) + { + var adder = ev.AddAccessor; + if (adder != null && (filter == null || filter(adder))) + yield return adder; + var remover = ev.RemoveAccessor; + if (remover != null && (filter == null || filter(remover))) + yield return remover; + var invoker = ev.InvokeAccessor; + if (invoker != null && (filter == null || filter(invoker))) + yield return remover; + } + } + #endregion + + #region GetOverrides + internal IEnumerable GetOverrides(MethodDefinitionHandle method) + { + var metadata = module.metadata; + var td = metadata.GetTypeDefinition(handle); + foreach (var implHandle in td.GetMethodImplementations()) + { + var impl = metadata.GetMethodImplementation(implHandle); + if (impl.MethodBody == method) + yield return module.ResolveMethod(impl.MethodDeclaration, new GenericContext(this.TypeParameters)); + } + } + + internal bool HasOverrides(MethodDefinitionHandle method) + { + var metadata = module.metadata; + var td = metadata.GetTypeDefinition(handle); + foreach (var implHandle in td.GetMethodImplementations()) + { + var impl = metadata.GetMethodImplementation(implHandle); + if (impl.MethodBody == method) + return true; + } + return false; + } + #endregion + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataTypeParameter.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataTypeParameter.cs new file mode 100644 index 0000000..c44c6f6 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MetadataTypeParameter.cs @@ -0,0 +1,260 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + sealed class MetadataTypeParameter : AbstractTypeParameter + { + readonly MetadataModule module; + readonly GenericParameterHandle handle; + + readonly GenericParameterAttributes attr; + + // lazy-loaded: + IReadOnlyList constraints; + byte unmanagedConstraint = ThreeState.Unknown; + const byte nullabilityNotYetLoaded = 255; + byte nullabilityConstraint = nullabilityNotYetLoaded; + + public static ITypeParameter[] Create(MetadataModule module, ITypeDefinition copyFromOuter, IEntity owner, GenericParameterHandleCollection handles) + { + if (handles.Count == 0) + return Empty.Array; + var outerTps = copyFromOuter.TypeParameters; + var tps = new ITypeParameter[handles.Count]; + var i = 0; + foreach (var handle in handles) + { + if (i < outerTps.Count) + tps[i] = outerTps[i]; + else + tps[i] = Create(module, owner, i, handle); + i++; + } + return tps; + } + + public static ITypeParameter[] Create(MetadataModule module, IEntity owner, GenericParameterHandleCollection handles) + { + if (handles.Count == 0) + return Empty.Array; + var tps = new ITypeParameter[handles.Count]; + var i = 0; + foreach (var handle in handles) + { + tps[i] = Create(module, owner, i, handle); + i++; + } + return tps; + } + + public static MetadataTypeParameter Create(MetadataModule module, IEntity owner, int index, GenericParameterHandle handle) + { + var metadata = module.metadata; + var gp = metadata.GetGenericParameter(handle); + Debug.Assert(gp.Index == index); + return new MetadataTypeParameter(module, owner, index, module.GetString(gp.Name), handle, gp.Attributes); + } + + private MetadataTypeParameter(MetadataModule module, IEntity owner, int index, string name, + GenericParameterHandle handle, GenericParameterAttributes attr) + : base(owner, index, name, GetVariance(attr)) + { + this.module = module; + this.handle = handle; + this.attr = attr; + } + + private static VarianceModifier GetVariance(GenericParameterAttributes attr) + { + switch (attr & GenericParameterAttributes.VarianceMask) + { + case GenericParameterAttributes.Contravariant: + return VarianceModifier.Contravariant; + case GenericParameterAttributes.Covariant: + return VarianceModifier.Covariant; + default: + return VarianceModifier.Invariant; + } + } + + public GenericParameterHandle MetadataToken => handle; + + public override IEnumerable GetAttributes() + { + var metadata = module.metadata; + var gp = metadata.GetGenericParameter(handle); + + var attributes = gp.GetCustomAttributes(); + var b = new AttributeListBuilder(module, attributes.Count); + b.Add(attributes, SymbolKind.TypeParameter); + return b.Build(); + } + + public override bool HasDefaultConstructorConstraint => (attr & GenericParameterAttributes.DefaultConstructorConstraint) != 0; + public override bool HasReferenceTypeConstraint => (attr & GenericParameterAttributes.ReferenceTypeConstraint) != 0; + public override bool HasValueTypeConstraint => (attr & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0; + + public override bool HasUnmanagedConstraint { + get { + if (unmanagedConstraint == ThreeState.Unknown) + { + unmanagedConstraint = ThreeState.From(LoadUnmanagedConstraint()); + } + return unmanagedConstraint == ThreeState.True; + } + } + + private bool LoadUnmanagedConstraint() + { + var metadata = module.metadata; + var gp = metadata.GetGenericParameter(handle); + return gp.GetCustomAttributes().HasKnownAttribute(metadata, KnownAttribute.IsUnmanaged); + } + + public override Nullability NullabilityConstraint { + get { + if (nullabilityConstraint == nullabilityNotYetLoaded) + { + nullabilityConstraint = (byte)LoadNullabilityConstraint(); + } + return (Nullability)nullabilityConstraint; + } + } + + Nullability LoadNullabilityConstraint() + { + if (!module.ShouldDecodeNullableAttributes(Owner)) + return Nullability.Oblivious; + + var metadata = module.metadata; + var gp = metadata.GetGenericParameter(handle); + + foreach (var handle in gp.GetCustomAttributes()) + { + var customAttribute = metadata.GetCustomAttribute(handle); + if (customAttribute.IsKnownAttribute(metadata, KnownAttribute.Nullable)) + { + var attrVal = customAttribute.DecodeValue(module.TypeProvider); + if (attrVal.FixedArguments.Length == 1) + { + if (attrVal.FixedArguments[0].Value is byte b && b <= 2) + { + return (Nullability)b; + } + } + } + } + if (Owner is MetadataMethod method) + { + return method.NullableContext; + } + else if (Owner is ITypeDefinition td) + { + return td.NullableContext; + } + else + { + return Nullability.Oblivious; + } + } + + public override IReadOnlyList TypeConstraints { + get { + var constraints = LazyInit.VolatileRead(ref this.constraints); + if (constraints == null) + { + constraints = LazyInit.GetOrSet(ref this.constraints, DecodeConstraints()); + } + return constraints; + } + } + + private IReadOnlyList DecodeConstraints() + { + var metadata = module.metadata; + var gp = metadata.GetGenericParameter(handle); + Nullability nullableContext; + if (Owner is ITypeDefinition typeDef) + { + nullableContext = typeDef.NullableContext; + } + else if (Owner is MetadataMethod method) + { + nullableContext = method.NullableContext; + } + else + { + nullableContext = Nullability.Oblivious; + } + + var constraintHandleCollection = gp.GetConstraints(); + var result = new List(constraintHandleCollection.Count + 1); + var hasNonInterfaceConstraint = false; + foreach (var constraintHandle in constraintHandleCollection) + { + var constraint = metadata.GetGenericParameterConstraint(constraintHandle); + var attrs = constraint.GetCustomAttributes(); + var ty = module.ResolveType(constraint.Type, new GenericContext(Owner), attrs, nullableContext); + if (attrs.Count == 0) + { + result.Add(new TypeConstraint(ty)); + } + else + { + var b = new AttributeListBuilder(module); + b.Add(attrs, SymbolKind.Constraint); + result.Add(new TypeConstraint(ty, b.Build())); + } + hasNonInterfaceConstraint |= (ty.Kind != TypeKind.Interface); + } + if (this.HasValueTypeConstraint) + { + result.Add(new TypeConstraint(Compilation.FindType(KnownTypeCode.ValueType))); + } + else if (!hasNonInterfaceConstraint) + { + result.Add(new TypeConstraint(Compilation.FindType(KnownTypeCode.Object))); + } + return result; + } + + public override int GetHashCode() + { + return 0x51fc5b83 ^ module.PEFile.GetHashCode() ^ handle.GetHashCode(); + } + + public override bool Equals(IType other) + { + return other is MetadataTypeParameter tp && handle == tp.handle && module.PEFile == tp.module.PEFile; + } + + public override string ToString() + { + return $"{MetadataTokens.GetToken(handle):X8} {ReflectionName}"; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MinimalCorlib.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MinimalCorlib.cs new file mode 100644 index 0000000..376f5c5 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/MinimalCorlib.cs @@ -0,0 +1,324 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// An artificial "assembly" that contains all known types () and no other types. + /// It does not contain any members. + /// + public sealed class MinimalCorlib : IModule + { + /// + /// Minimal corlib instance containing all known types. + /// + public static readonly IModuleReference Instance = new CorlibModuleReference(KnownTypeReference.AllKnownTypes); + + public static IModuleReference CreateWithTypes(IEnumerable types) + { + return new CorlibModuleReference(types); + } + + public ICompilation Compilation { get; } + CorlibTypeDefinition[] typeDefinitions; + readonly CorlibNamespace rootNamespace; + + private MinimalCorlib(ICompilation compilation, IEnumerable types) + { + this.Compilation = compilation; + this.typeDefinitions = types.Select(ktr => new CorlibTypeDefinition(this, ktr.KnownTypeCode)).ToArray(); + this.rootNamespace = new CorlibNamespace(this, null, string.Empty, string.Empty); + } + + bool IModule.IsMainModule => Compilation.MainModule == this; + + string IModule.AssemblyName => "corlib"; + string IModule.FullAssemblyName => "corlib"; + string ISymbol.Name => "corlib"; + SymbolKind ISymbol.SymbolKind => SymbolKind.Module; + + Metadata.PEFile IModule.PEFile => null; + INamespace IModule.RootNamespace => rootNamespace; + + public IEnumerable TopLevelTypeDefinitions => typeDefinitions.Where(td => td != null); + public IEnumerable TypeDefinitions => TopLevelTypeDefinitions; + + public ITypeDefinition GetTypeDefinition(TopLevelTypeName topLevelTypeName) + { + foreach (var typeDef in typeDefinitions) + { + if (typeDef.FullTypeName == topLevelTypeName) + return typeDef; + } + return null; + } + + IEnumerable IModule.GetAssemblyAttributes() => EmptyList.Instance; + IEnumerable IModule.GetModuleAttributes() => EmptyList.Instance; + + bool IModule.InternalsVisibleTo(IModule module) + { + return module == this; + } + + sealed class CorlibModuleReference : IModuleReference + { + readonly IEnumerable types; + + public CorlibModuleReference(IEnumerable types) + { + this.types = types; + } + + IModule IModuleReference.Resolve(ITypeResolveContext context) + { + return new MinimalCorlib(context.Compilation, types); + } + } + + sealed class CorlibNamespace : INamespace + { + readonly MinimalCorlib corlib; + internal List childNamespaces = new List(); + public INamespace ParentNamespace { get; } + public string FullName { get; } + public string Name { get; } + + public CorlibNamespace(MinimalCorlib corlib, INamespace parentNamespace, string fullName, string name) + { + this.corlib = corlib; + this.ParentNamespace = parentNamespace; + this.FullName = fullName; + this.Name = name; + } + + string INamespace.ExternAlias => string.Empty; + + IEnumerable INamespace.ChildNamespaces => childNamespaces; + IEnumerable INamespace.Types => corlib.TopLevelTypeDefinitions.Where(td => td.Namespace == FullName); + + IEnumerable INamespace.ContributingModules => new[] { corlib }; + + SymbolKind ISymbol.SymbolKind => SymbolKind.Namespace; + ICompilation ICompilationProvider.Compilation => corlib.Compilation; + + INamespace INamespace.GetChildNamespace(string name) + { + return childNamespaces.FirstOrDefault(ns => ns.Name == name); + } + + ITypeDefinition INamespace.GetTypeDefinition(string name, int typeParameterCount) + { + return corlib.GetTypeDefinition(this.FullName, name, typeParameterCount); + } + } + + sealed class CorlibTypeDefinition : ITypeDefinition + { + readonly MinimalCorlib corlib; + readonly KnownTypeCode typeCode; + readonly TypeKind typeKind; + + public CorlibTypeDefinition(MinimalCorlib corlib, KnownTypeCode typeCode) + { + this.corlib = corlib; + this.typeCode = typeCode; + this.typeKind = KnownTypeReference.Get(typeCode).typeKind; + } + + IReadOnlyList ITypeDefinition.NestedTypes => EmptyList.Instance; + IReadOnlyList ITypeDefinition.Members => EmptyList.Instance; + IEnumerable ITypeDefinition.Fields => EmptyList.Instance; + IEnumerable ITypeDefinition.Methods => EmptyList.Instance; + IEnumerable ITypeDefinition.Properties => EmptyList.Instance; + IEnumerable ITypeDefinition.Events => EmptyList.Instance; + + KnownTypeCode ITypeDefinition.KnownTypeCode => typeCode; + + IType ITypeDefinition.EnumUnderlyingType => SpecialType.UnknownType; + + public FullTypeName FullTypeName => KnownTypeReference.Get(typeCode).TypeName; + + ITypeDefinition IEntity.DeclaringTypeDefinition => null; + IType ITypeDefinition.DeclaringType => null; + IType IType.DeclaringType => null; + IType IEntity.DeclaringType => null; + + bool ITypeDefinition.HasExtensionMethods => false; + bool ITypeDefinition.IsReadOnly => false; + + TypeKind IType.Kind => typeKind; + + bool? IType.IsReferenceType { + get { + switch (typeKind) + { + case TypeKind.Class: + case TypeKind.Interface: + return true; + case TypeKind.Struct: + case TypeKind.Enum: + return false; + default: + return null; + } + } + } + + bool IType.IsByRefLike => false; + Nullability IType.Nullability => Nullability.Oblivious; + Nullability ITypeDefinition.NullableContext => Nullability.Oblivious; + + IType IType.ChangeNullability(Nullability nullability) + { + if (nullability == Nullability.Oblivious) + return this; + else + return new NullabilityAnnotatedType(this, nullability); + } + + int IType.TypeParameterCount => KnownTypeReference.Get(typeCode).TypeParameterCount; + + IReadOnlyList IType.TypeParameters => DummyTypeParameter.GetClassTypeParameterList(KnownTypeReference.Get(typeCode).TypeParameterCount); + IReadOnlyList IType.TypeArguments => DummyTypeParameter.GetClassTypeParameterList(KnownTypeReference.Get(typeCode).TypeParameterCount); + + IEnumerable IType.DirectBaseTypes { + get { + var baseType = KnownTypeReference.Get(typeCode).baseType; + if (baseType != KnownTypeCode.None) + return new[] { corlib.Compilation.FindType(baseType) }; + else + return EmptyList.Instance; + } + } + + EntityHandle IEntity.MetadataToken => MetadataTokens.TypeDefinitionHandle(0); + + public string Name => KnownTypeReference.Get(typeCode).Name; + + IModule IEntity.ParentModule => corlib; + + Accessibility IEntity.Accessibility => Accessibility.Public; + + bool IEntity.IsStatic => false; + bool IEntity.IsAbstract => typeKind == TypeKind.Interface; + bool IEntity.IsSealed => typeKind == TypeKind.Struct; + + SymbolKind ISymbol.SymbolKind => SymbolKind.TypeDefinition; + + ICompilation ICompilationProvider.Compilation => corlib.Compilation; + + string INamedElement.FullName { + get { + var ktr = KnownTypeReference.Get(typeCode); + return ktr.Namespace + "." + ktr.Name; + } + } + + string INamedElement.ReflectionName => KnownTypeReference.Get(typeCode).TypeName.ReflectionName; + + string INamedElement.Namespace => KnownTypeReference.Get(typeCode).Namespace; + + bool IEquatable.Equals(IType other) + { + return this == other; + } + + IEnumerable IType.GetAccessors(Predicate filter, GetMemberOptions options) + { + return EmptyList.Instance; + } + + IEnumerable IEntity.GetAttributes() + { + return EmptyList.Instance; + } + + IEnumerable IType.GetConstructors(Predicate filter, GetMemberOptions options) + { + return EmptyList.Instance; + } + + IEnumerable IType.GetEvents(Predicate filter, GetMemberOptions options) + { + return EmptyList.Instance; + } + + IEnumerable IType.GetFields(Predicate filter, GetMemberOptions options) + { + return EmptyList.Instance; + } + + IEnumerable IType.GetMembers(Predicate filter, GetMemberOptions options) + { + return EmptyList.Instance; + } + + IEnumerable IType.GetMethods(Predicate filter, GetMemberOptions options) + { + return EmptyList.Instance; + } + + IEnumerable IType.GetMethods(IReadOnlyList typeArguments, Predicate filter, GetMemberOptions options) + { + return EmptyList.Instance; + } + + IEnumerable IType.GetNestedTypes(Predicate filter, GetMemberOptions options) + { + return EmptyList.Instance; + } + + IEnumerable IType.GetNestedTypes(IReadOnlyList typeArguments, Predicate filter, GetMemberOptions options) + { + return EmptyList.Instance; + } + + IEnumerable IType.GetProperties(Predicate filter, GetMemberOptions options) + { + return EmptyList.Instance; + } + + ITypeDefinition IType.GetDefinition() => this; + TypeParameterSubstitution IType.GetSubstitution() => TypeParameterSubstitution.Identity; + + IType IType.AcceptVisitor(TypeVisitor visitor) + { + return visitor.VisitTypeDefinition(this); + } + + IType IType.VisitChildren(TypeVisitor visitor) + { + return this; + } + + public override string ToString() + { + return $"[MinimalCorlibType {typeCode}]"; + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/NestedTypeReference.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/NestedTypeReference.cs new file mode 100644 index 0000000..3c24dad --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/NestedTypeReference.cs @@ -0,0 +1,104 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Type reference used to reference nested types. + /// + [Serializable] + public sealed class NestedTypeReference : ITypeReference, ISupportsInterning + { + readonly ITypeReference declaringTypeRef; + readonly string name; + readonly int additionalTypeParameterCount; + readonly bool? isReferenceType; + + /// + /// Creates a new NestedTypeReference. + /// + /// Reference to the declaring type. + /// Name of the nested class + /// Number of type parameters on the inner class (without type parameters on baseTypeRef) + /// + /// must be exactly the (unbound) declaring type, not a derived type, not a parameterized type. + /// NestedTypeReference thus always resolves to a type definition, never to (partially) parameterized types. + /// + public NestedTypeReference(ITypeReference declaringTypeRef, string name, int additionalTypeParameterCount, bool? isReferenceType = null) + { + if (declaringTypeRef == null) + throw new ArgumentNullException(nameof(declaringTypeRef)); + if (name == null) + throw new ArgumentNullException(nameof(name)); + this.declaringTypeRef = declaringTypeRef; + this.name = name; + this.additionalTypeParameterCount = additionalTypeParameterCount; + this.isReferenceType = isReferenceType; + } + + public ITypeReference DeclaringTypeReference { + get { return declaringTypeRef; } + } + + public string Name { + get { return name; } + } + + public int AdditionalTypeParameterCount { + get { return additionalTypeParameterCount; } + } + + public IType Resolve(ITypeResolveContext context) + { + var declaringType = declaringTypeRef.Resolve(context) as ITypeDefinition; + if (declaringType != null) + { + var tpc = declaringType.TypeParameterCount; + foreach (IType type in declaringType.NestedTypes) + { + if (type.Name == name && type.TypeParameterCount == tpc + additionalTypeParameterCount) + return type; + } + } + return new UnknownType(null, name, additionalTypeParameterCount); + } + + public override string ToString() + { + if (additionalTypeParameterCount == 0) + return declaringTypeRef + "+" + name; + else + return declaringTypeRef + "+" + name + "`" + additionalTypeParameterCount; + } + + int ISupportsInterning.GetHashCodeForInterning() + { + return declaringTypeRef.GetHashCode() ^ name.GetHashCode() ^ additionalTypeParameterCount; + } + + bool ISupportsInterning.EqualsForInterning(ISupportsInterning other) + { + var o = other as NestedTypeReference; + return o != null && declaringTypeRef == o.declaringTypeRef && name == o.name + && additionalTypeParameterCount == o.additionalTypeParameterCount + && isReferenceType == o.isReferenceType; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/NullabilityAnnotatedType.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/NullabilityAnnotatedType.cs new file mode 100644 index 0000000..407cffa --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/NullabilityAnnotatedType.cs @@ -0,0 +1,123 @@ +using System.Collections.Generic; +using System.Diagnostics; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// A decorator that annotates the nullability status for a type. + /// Note: ArrayType does not use a decorator, but has direct support for nullability. + /// + public class NullabilityAnnotatedType : DecoratedType, IType + { + readonly Nullability nullability; + + internal NullabilityAnnotatedType(IType type, Nullability nullability) + : base(type) + { + Debug.Assert(type.Nullability == Nullability.Oblivious); + Debug.Assert(nullability != Nullability.Oblivious); + // Due to IType -> concrete type casts all over the type system, we can insert + // the NullabilityAnnotatedType wrapper only in some limited places. + Debug.Assert(type is ITypeDefinition + || type.Kind == TypeKind.Dynamic + || type.Kind == TypeKind.Unknown + || (type is ITypeParameter && this is ITypeParameter)); + this.nullability = nullability; + } + + public Nullability Nullability => nullability; + + public IType TypeWithoutAnnotation => baseType; + + public override IType AcceptVisitor(TypeVisitor visitor) + { + return visitor.VisitNullabilityAnnotatedType(this); + } + + public override bool Equals(IType other) + { + return other is NullabilityAnnotatedType nat + && nat.nullability == nullability + && nat.baseType.Equals(baseType); + } + + public override IType ChangeNullability(Nullability nullability) + { + if (nullability == this.nullability) + return this; + else + return baseType.ChangeNullability(nullability); + } + + public override IType VisitChildren(TypeVisitor visitor) + { + var newBase = baseType.AcceptVisitor(visitor); + if (newBase != baseType) + { + if (newBase.Nullability == Nullability.Nullable) + { + // `T!` with substitution T=`U?` becomes `U?` + // This happens during type substitution for generic methods. + return newBase; + } + if (newBase.Kind == TypeKind.TypeParameter || newBase.IsReferenceType == true) + { + return newBase.ChangeNullability(nullability); + } + else + { + // `T!` with substitution T=`int` becomes `int`, not `int!` + return newBase; + } + } + else + { + return this; + } + } + + public override string ToString() + { + switch (nullability) + { + case Nullability.Nullable: + return $"{baseType.ToString()}?"; + case Nullability.NotNullable: + return $"{baseType.ToString()}!"; + default: + Debug.Assert(nullability == Nullability.Oblivious); + return $"{baseType.ToString()}~"; + } + } + } + + public sealed class NullabilityAnnotatedTypeParameter : NullabilityAnnotatedType, ITypeParameter + { + readonly new ITypeParameter baseType; + + internal NullabilityAnnotatedTypeParameter(ITypeParameter type, Nullability nullability) + : base(type, nullability) + { + this.baseType = type; + } + + public ITypeParameter OriginalTypeParameter => baseType; + + SymbolKind ITypeParameter.OwnerType => baseType.OwnerType; + IEntity ITypeParameter.Owner => baseType.Owner; + int ITypeParameter.Index => baseType.Index; + string ITypeParameter.Name => baseType.Name; + string ISymbol.Name => baseType.Name; + VarianceModifier ITypeParameter.Variance => baseType.Variance; + IType ITypeParameter.EffectiveBaseClass => baseType.EffectiveBaseClass; + IReadOnlyCollection ITypeParameter.EffectiveInterfaceSet => baseType.EffectiveInterfaceSet; + bool ITypeParameter.HasDefaultConstructorConstraint => baseType.HasDefaultConstructorConstraint; + bool ITypeParameter.HasReferenceTypeConstraint => baseType.HasReferenceTypeConstraint; + bool ITypeParameter.HasValueTypeConstraint => baseType.HasValueTypeConstraint; + bool ITypeParameter.HasUnmanagedConstraint => baseType.HasUnmanagedConstraint; + Nullability ITypeParameter.NullabilityConstraint => baseType.NullabilityConstraint; + IReadOnlyList ITypeParameter.TypeConstraints => baseType.TypeConstraints; + SymbolKind ISymbol.SymbolKind => SymbolKind.TypeParameter; + IEnumerable ITypeParameter.GetAttributes() => baseType.GetAttributes(); + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/PinnedType.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/PinnedType.cs new file mode 100644 index 0000000..326a9b9 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/PinnedType.cs @@ -0,0 +1,45 @@ +// Copyright (c) 2017 Siegfried Pammer +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using SRM = System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + public sealed class PinnedType : TypeWithElementType + { + public PinnedType(IType elementType) + : base(elementType) + { + } + + public override string NameSuffix => " pinned"; + + public override bool? IsReferenceType => elementType.IsReferenceType; + public override bool IsByRefLike => elementType.IsByRefLike; + + public override TypeKind Kind => TypeKind.Other; + + public override IType VisitChildren(TypeVisitor visitor) + { + var newType = elementType.AcceptVisitor(visitor); + if (newType == elementType) + return this; + return new PinnedType(newType); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SimpleCompilation.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SimpleCompilation.cs new file mode 100644 index 0000000..28f90b5 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SimpleCompilation.cs @@ -0,0 +1,165 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Simple compilation implementation. + /// + public class SimpleCompilation : ICompilation + { + readonly CacheManager cacheManager = new CacheManager(); + IModule mainModule; + KnownTypeCache knownTypeCache; + IReadOnlyList assemblies; + IReadOnlyList referencedAssemblies; + bool initialized; + INamespace rootNamespace; + + public SimpleCompilation(IModuleReference mainAssembly, params IModuleReference[] assemblyReferences) + { + Init(mainAssembly, assemblyReferences); + } + + public SimpleCompilation(IModuleReference mainAssembly, IEnumerable assemblyReferences) + { + Init(mainAssembly, assemblyReferences); + } + + protected SimpleCompilation() + { + } + + protected void Init(IModuleReference mainAssembly, IEnumerable assemblyReferences) + { + if (mainAssembly == null) + throw new ArgumentNullException(nameof(mainAssembly)); + if (assemblyReferences == null) + throw new ArgumentNullException(nameof(assemblyReferences)); + var context = new SimpleTypeResolveContext(this); + this.mainModule = mainAssembly.Resolve(context); + var assemblies = new List(); + assemblies.Add(this.mainModule); + var referencedAssemblies = new List(); + foreach (var asmRef in assemblyReferences) + { + IModule asm; + try + { + asm = asmRef.Resolve(context); + } + catch (InvalidOperationException) + { + throw new InvalidOperationException("Tried to initialize compilation with an invalid assembly reference. (Forgot to load the assembly reference ? - see CecilLoader)"); + } + if (asm != null && !assemblies.Contains(asm)) + assemblies.Add(asm); + if (asm != null && !referencedAssemblies.Contains(asm)) + referencedAssemblies.Add(asm); + } + this.assemblies = assemblies.AsReadOnly(); + this.referencedAssemblies = referencedAssemblies.AsReadOnly(); + this.knownTypeCache = new KnownTypeCache(this); + this.initialized = true; + } + + public IModule MainModule { + get { + if (!initialized) + throw new InvalidOperationException("Compilation isn't initialized yet"); + return mainModule; + } + } + + public IReadOnlyList Modules { + get { + if (!initialized) + throw new InvalidOperationException("Compilation isn't initialized yet"); + return assemblies; + } + } + + public IReadOnlyList ReferencedModules { + get { + if (!initialized) + throw new InvalidOperationException("Compilation isn't initialized yet"); + return referencedAssemblies; + } + } + + public INamespace RootNamespace { + get { + var ns = LazyInit.VolatileRead(ref this.rootNamespace); + if (ns != null) + { + return ns; + } + else + { + if (!initialized) + throw new InvalidOperationException("Compilation isn't initialized yet"); + return LazyInit.GetOrSet(ref this.rootNamespace, CreateRootNamespace()); + } + } + } + + protected virtual INamespace CreateRootNamespace() + { + // SimpleCompilation does not support extern aliases; but derived classes might. + // CreateRootNamespace() is virtual so that derived classes can change the global namespace. + var namespaces = new INamespace[referencedAssemblies.Count + 1]; + namespaces[0] = mainModule.RootNamespace; + for (var i = 0; i < referencedAssemblies.Count; i++) + { + namespaces[i + 1] = referencedAssemblies[i].RootNamespace; + } + return new MergedNamespace(this, namespaces); + } + + public CacheManager CacheManager { + get { return cacheManager; } + } + + public virtual INamespace GetNamespaceForExternAlias(string alias) + { + if (string.IsNullOrEmpty(alias)) + return this.RootNamespace; + // SimpleCompilation does not support extern aliases; but derived classes might. + return null; + } + + public IType FindType(KnownTypeCode typeCode) + { + return knownTypeCache.FindType(typeCode); + } + + public StringComparer NameComparer { + get { return StringComparer.Ordinal; } + } + + public override string ToString() + { + return "[" + GetType().Name + " " + mainModule.AssemblyName + "]"; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedEvent.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedEvent.cs new file mode 100644 index 0000000..7564458 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedEvent.cs @@ -0,0 +1,75 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Represents a specialized IEvent (event after type substitution). + /// + public class SpecializedEvent : SpecializedMember, IEvent + { + public static IEvent Create(IEvent ev, TypeParameterSubstitution substitution) + { + if (TypeParameterSubstitution.Identity.Equals(substitution) + || ev.DeclaringType.TypeParameterCount == 0) + { + return ev; + } + if (substitution.MethodTypeArguments != null && substitution.MethodTypeArguments.Count > 0) + substitution = new TypeParameterSubstitution(substitution.ClassTypeArguments, EmptyList.Instance); + return new SpecializedEvent(ev, substitution); + } + + readonly IEvent eventDefinition; + + public SpecializedEvent(IEvent eventDefinition, TypeParameterSubstitution substitution) + : base(eventDefinition) + { + this.eventDefinition = eventDefinition; + AddSubstitution(substitution); + } + + public bool CanAdd { + get { return eventDefinition.CanAdd; } + } + + public bool CanRemove { + get { return eventDefinition.CanRemove; } + } + + public bool CanInvoke { + get { return eventDefinition.CanInvoke; } + } + + IMethod addAccessor, removeAccessor, invokeAccessor; + + public IMethod AddAccessor { + get { return WrapAccessor(ref this.addAccessor, eventDefinition.AddAccessor); } + } + + public IMethod RemoveAccessor { + get { return WrapAccessor(ref this.removeAccessor, eventDefinition.RemoveAccessor); } + } + + public IMethod InvokeAccessor { + get { return WrapAccessor(ref this.invokeAccessor, eventDefinition.InvokeAccessor); } + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedField.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedField.cs new file mode 100644 index 0000000..ac0dc9c --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedField.cs @@ -0,0 +1,69 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Represents a specialized IField (field after type substitution). + /// + public class SpecializedField : SpecializedMember, IField + { + internal static IField Create(IField fieldDefinition, TypeParameterSubstitution substitution) + { + if (TypeParameterSubstitution.Identity.Equals(substitution) || fieldDefinition.DeclaringType.TypeParameterCount == 0) + { + return fieldDefinition; + } + if (substitution.MethodTypeArguments != null && substitution.MethodTypeArguments.Count > 0) + substitution = new TypeParameterSubstitution(substitution.ClassTypeArguments, EmptyList.Instance); + return new SpecializedField(fieldDefinition, substitution); + } + + readonly IField fieldDefinition; + + public SpecializedField(IField fieldDefinition, TypeParameterSubstitution substitution) + : base(fieldDefinition) + { + this.fieldDefinition = fieldDefinition; + AddSubstitution(substitution); + } + + public bool IsReadOnly { + get { return fieldDefinition.IsReadOnly; } + } + + public bool IsVolatile { + get { return fieldDefinition.IsVolatile; } + } + + IType IVariable.Type { + get { return this.ReturnType; } + } + + public bool IsConst { + get { return fieldDefinition.IsConst; } + } + + public object GetConstantValue(bool throwOnInvalidMetadata) + { + return fieldDefinition.GetConstantValue(throwOnInvalidMetadata); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMember.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMember.cs new file mode 100644 index 0000000..3d422a9 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMember.cs @@ -0,0 +1,330 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Text; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Represents a SpecializedMember (a member on which type substitution has been performed). + /// + public abstract class SpecializedMember : IMember + { + protected readonly IMember baseMember; + TypeParameterSubstitution substitution; + + IType declaringType; + IType returnType; + + protected SpecializedMember(IMember memberDefinition) + { + if (memberDefinition == null) + throw new ArgumentNullException(nameof(memberDefinition)); + if (memberDefinition is SpecializedMember) + throw new ArgumentException("Member definition cannot be specialized. Please use IMember.Specialize() instead of directly constructing SpecializedMember instances."); + + this.baseMember = memberDefinition; + this.substitution = TypeParameterSubstitution.Identity; + } + + /// + /// Performs a substitution. This method may only be called by constructors in derived classes. + /// + protected void AddSubstitution(TypeParameterSubstitution newSubstitution) + { + Debug.Assert(declaringType == null); + Debug.Assert(returnType == null); + this.substitution = TypeParameterSubstitution.Compose(newSubstitution, this.substitution); + } + + internal IMethod WrapAccessor(ref IMethod cachingField, IMethod accessorDefinition) + { + if (accessorDefinition == null) + return null; + var result = LazyInit.VolatileRead(ref cachingField); + if (result != null) + { + return result; + } + else + { + var sm = accessorDefinition.Specialize(substitution); + //sm.AccessorOwner = this; + return LazyInit.GetOrSet(ref cachingField, sm); + } + } + + /// + /// Gets the substitution belonging to this specialized member. + /// + public TypeParameterSubstitution Substitution { + get { return substitution; } + } + + public IType DeclaringType { + get { + var result = LazyInit.VolatileRead(ref this.declaringType); + if (result != null) + return result; + var definitionDeclaringType = baseMember.DeclaringType; + var definitionDeclaringTypeDef = definitionDeclaringType as ITypeDefinition; + if (definitionDeclaringTypeDef != null && definitionDeclaringType.TypeParameterCount > 0) + { + if (substitution.ClassTypeArguments != null && substitution.ClassTypeArguments.Count == definitionDeclaringType.TypeParameterCount) + { + result = new ParameterizedType(definitionDeclaringTypeDef, substitution.ClassTypeArguments); + } + else + { + result = new ParameterizedType(definitionDeclaringTypeDef, definitionDeclaringTypeDef.TypeParameters).AcceptVisitor(substitution); + } + } + else if (definitionDeclaringType != null) + { + result = definitionDeclaringType.AcceptVisitor(substitution); + } + return LazyInit.GetOrSet(ref this.declaringType, result); + } + internal set { + // This setter is used as an optimization when the code constructing + // the SpecializedMember already knows the declaring type. + Debug.Assert(this.declaringType == null); + // As this setter is used only during construction before the member is published + // to other threads, we don't need a volatile write. + this.declaringType = value; + } + } + + public IMember MemberDefinition { + get { return baseMember.MemberDefinition; } + } + + public IType ReturnType { + get { + var result = LazyInit.VolatileRead(ref this.returnType); + if (result != null) + return result; + else + return LazyInit.GetOrSet(ref this.returnType, baseMember.ReturnType.AcceptVisitor(substitution)); + } + protected set { + // This setter is used for LiftedUserDefinedOperator, a special case of specialized member + // (not a normal type parameter substitution). + + // As this setter is used only during construction before the member is published + // to other threads, we don't need a volatile write. + this.returnType = value; + } + } + + public System.Reflection.Metadata.EntityHandle MetadataToken => baseMember.MetadataToken; + + public bool IsVirtual { + get { return baseMember.IsVirtual; } + } + + public bool IsOverride { + get { return baseMember.IsOverride; } + } + + public bool IsOverridable { + get { return baseMember.IsOverridable; } + } + + public SymbolKind SymbolKind { + get { return baseMember.SymbolKind; } + } + + public ITypeDefinition DeclaringTypeDefinition { + get { return baseMember.DeclaringTypeDefinition; } + } + + IEnumerable IEntity.GetAttributes() => baseMember.GetAttributes(); + + public IEnumerable ExplicitlyImplementedInterfaceMembers { + get { + // Note: if the interface is generic, then the interface members should already be specialized, + // so we only need to append our substitution. + return baseMember.ExplicitlyImplementedInterfaceMembers.Select(m => m.Specialize(substitution)); + } + } + + public bool IsExplicitInterfaceImplementation { + get { return baseMember.IsExplicitInterfaceImplementation; } + } + + public Accessibility Accessibility { + get { return baseMember.Accessibility; } + } + + public bool IsStatic { + get { return baseMember.IsStatic; } + } + + public bool IsAbstract { + get { return baseMember.IsAbstract; } + } + + public bool IsSealed { + get { return baseMember.IsSealed; } + } + + public string FullName { + get { return baseMember.FullName; } + } + + public string Name { + get { return baseMember.Name; } + } + + public string Namespace { + get { return baseMember.Namespace; } + } + + public string ReflectionName { + get { return baseMember.ReflectionName; } + } + + public ICompilation Compilation { + get { return baseMember.Compilation; } + } + + public IModule ParentModule { + get { return baseMember.ParentModule; } + } + + public virtual IMember Specialize(TypeParameterSubstitution newSubstitution) + { + return baseMember.Specialize(TypeParameterSubstitution.Compose(newSubstitution, this.substitution)); + } + + public virtual bool Equals(IMember obj, TypeVisitor typeNormalization) + { + var other = obj as SpecializedMember; + if (other == null) + return false; + return this.baseMember.Equals(other.baseMember, typeNormalization) + && this.substitution.Equals(other.substitution, typeNormalization); + } + + public override bool Equals(object obj) + { + var other = obj as SpecializedMember; + if (other == null) + return false; + return this.baseMember.Equals(other.baseMember) && this.substitution.Equals(other.substitution); + } + + public override int GetHashCode() + { + unchecked + { + return 1000000007 * baseMember.GetHashCode() + 1000000009 * substitution.GetHashCode(); + } + } + + public override string ToString() + { + var b = new StringBuilder("["); + b.Append(GetType().Name); + b.Append(' '); + b.Append(this.DeclaringType.ToString()); + b.Append('.'); + b.Append(this.Name); + b.Append(':'); + b.Append(this.ReturnType.ToString()); + b.Append(']'); + return b.ToString(); + } + } + + public abstract class SpecializedParameterizedMember : SpecializedMember, IParameterizedMember + { + IReadOnlyList parameters; + + protected SpecializedParameterizedMember(IParameterizedMember memberDefinition) + : base(memberDefinition) + { + } + + public IReadOnlyList Parameters { + get { + var result = LazyInit.VolatileRead(ref this.parameters); + if (result != null) + return result; + else + return LazyInit.GetOrSet(ref this.parameters, CreateParameters(t => t.AcceptVisitor(this.Substitution))); + } + protected set { + // This setter is used for LiftedUserDefinedOperator, a special case of specialized member + // (not a normal type parameter substitution). + + // As this setter is used only during construction before the member is published + // to other threads, we don't need a volatile write. + this.parameters = value; + } + } + + protected IParameter[] CreateParameters(Func substitution) + { + var paramDefs = ((IParameterizedMember)this.baseMember).Parameters; + if (paramDefs.Count == 0) + { + return Empty.Array; + } + else + { + var parameters = new IParameter[paramDefs.Count]; + for (var i = 0; i < parameters.Length; i++) + { + var p = paramDefs[i]; + var newType = substitution(p.Type); + parameters[i] = new SpecializedParameter(p, newType, this); + } + return parameters; + } + } + + public override string ToString() + { + var b = new StringBuilder("["); + b.Append(GetType().Name); + b.Append(' '); + b.Append(this.DeclaringType.ReflectionName); + b.Append('.'); + b.Append(this.Name); + b.Append('('); + for (var i = 0; i < this.Parameters.Count; i++) + { + if (i > 0) + b.Append(", "); + b.Append(this.Parameters[i].ToString()); + } + b.Append("):"); + b.Append(this.ReturnType.ReflectionName); + b.Append(']'); + return b.ToString(); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMethod.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMethod.cs new file mode 100644 index 0000000..7f2bf55 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedMethod.cs @@ -0,0 +1,299 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Text; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Represents a specialized IMethod (e.g. after type substitution). + /// + public class SpecializedMethod : SpecializedParameterizedMember, IMethod + { + internal static IMethod Create(IMethod methodDefinition, TypeParameterSubstitution substitution) + { + if (TypeParameterSubstitution.Identity.Equals(substitution)) + return methodDefinition; + if (methodDefinition.DeclaringType is ArrayType) + return new SpecializedMethod(methodDefinition, substitution); + if (methodDefinition.TypeParameters.Count == 0) + { + if (methodDefinition.DeclaringType.TypeParameterCount == 0) + return methodDefinition; + if (substitution.MethodTypeArguments != null && substitution.MethodTypeArguments.Count > 0) + substitution = new TypeParameterSubstitution(substitution.ClassTypeArguments, EmptyList.Instance); + } + return new SpecializedMethod(methodDefinition, substitution); + } + + readonly IMethod methodDefinition; + readonly ITypeParameter[] specializedTypeParameters; + readonly bool isParameterized; + readonly TypeParameterSubstitution substitutionWithoutSpecializedTypeParameters; + + public SpecializedMethod(IMethod methodDefinition, TypeParameterSubstitution substitution) + : base(methodDefinition) + { + if (substitution == null) + throw new ArgumentNullException(nameof(substitution)); + this.methodDefinition = methodDefinition; + this.isParameterized = substitution.MethodTypeArguments != null; + if (methodDefinition.TypeParameters.Count > 0) + { + // The method is generic, so we need to specialize the type parameters + // (for specializing the constraints, and also to set the correct Owner) + specializedTypeParameters = new ITypeParameter[methodDefinition.TypeParameters.Count]; + for (var i = 0; i < specializedTypeParameters.Length; i++) + { + specializedTypeParameters[i] = new SpecializedTypeParameter(methodDefinition.TypeParameters[i], this); + } + if (!isParameterized) + { + // Add substitution that replaces the base method's type parameters with our specialized version + // but do this only if the type parameters on the baseMember have not already been substituted + substitutionWithoutSpecializedTypeParameters = this.Substitution; + AddSubstitution(new TypeParameterSubstitution(null, specializedTypeParameters)); + } + } + // Add the main substitution after the method type parameter specialization. + AddSubstitution(substitution); + if (substitutionWithoutSpecializedTypeParameters != null) + { + // If we already have a substitution without specialized type parameters, update that: + substitutionWithoutSpecializedTypeParameters = TypeParameterSubstitution.Compose(substitution, substitutionWithoutSpecializedTypeParameters); + } + else + { + // Otherwise just use the whole substitution, as that doesn't contain specialized type parameters + // in this case. + substitutionWithoutSpecializedTypeParameters = this.Substitution; + } + if (specializedTypeParameters != null) + { + // Set the substitution on the type parameters to the final composed substitution + foreach (var tp in specializedTypeParameters.OfType()) + { + if (tp.Owner == this) + tp.substitution = base.Substitution; + } + } + } + + public IReadOnlyList TypeArguments { + get { return this.Substitution.MethodTypeArguments ?? EmptyList.Instance; } + } + + public IEnumerable GetReturnTypeAttributes() => methodDefinition.GetReturnTypeAttributes(); + public bool ReturnTypeIsRefReadOnly => methodDefinition.ReturnTypeIsRefReadOnly; + + bool IMethod.ThisIsRefReadOnly => methodDefinition.ThisIsRefReadOnly; + bool IMethod.IsInitOnly => methodDefinition.IsInitOnly; + + public IReadOnlyList TypeParameters { + get { + return specializedTypeParameters ?? methodDefinition.TypeParameters; + } + } + + public bool IsExtensionMethod { + get { return methodDefinition.IsExtensionMethod; } + } + + public bool IsLocalFunction { + get { return methodDefinition.IsLocalFunction; } + } + + public bool IsConstructor { + get { return methodDefinition.IsConstructor; } + } + + public bool IsDestructor { + get { return methodDefinition.IsDestructor; } + } + + public bool IsOperator { + get { return methodDefinition.IsOperator; } + } + + public bool HasBody { + get { return methodDefinition.HasBody; } + } + + public bool IsAccessor { + get { return methodDefinition.IsAccessor; } + } + + public MethodSemanticsAttributes AccessorKind => methodDefinition.AccessorKind; + + public IMethod ReducedFrom { + get { return null; } + } + + IMember accessorOwner; + + public IMember AccessorOwner { + get { + var result = LazyInit.VolatileRead(ref accessorOwner); + if (result != null) + { + return result; + } + else + { + var ownerDefinition = methodDefinition.AccessorOwner; + if (ownerDefinition == null) + return null; + result = ownerDefinition.Specialize(this.Substitution); + return LazyInit.GetOrSet(ref accessorOwner, result); + } + } + internal set { + accessorOwner = value; + } + } + + public override bool Equals(IMember obj, TypeVisitor typeNormalization) + { + var other = obj as SpecializedMethod; + if (other == null) + return false; + return this.baseMember.Equals(other.baseMember, typeNormalization) + && this.substitutionWithoutSpecializedTypeParameters.Equals(other.substitutionWithoutSpecializedTypeParameters, typeNormalization); + } + + public override bool Equals(object obj) + { + var other = obj as SpecializedMethod; + if (other == null) + return false; + return this.baseMember.Equals(other.baseMember) && this.substitutionWithoutSpecializedTypeParameters.Equals(other.substitutionWithoutSpecializedTypeParameters); + } + + public override int GetHashCode() + { + unchecked + { + return 1000000013 * baseMember.GetHashCode() + 1000000009 * substitutionWithoutSpecializedTypeParameters.GetHashCode(); + } + } + + public override IMember Specialize(TypeParameterSubstitution newSubstitution) + { + return methodDefinition.Specialize(TypeParameterSubstitution.Compose(newSubstitution, substitutionWithoutSpecializedTypeParameters)); + } + + IMethod IMethod.Specialize(TypeParameterSubstitution newSubstitution) + { + return methodDefinition.Specialize(TypeParameterSubstitution.Compose(newSubstitution, substitutionWithoutSpecializedTypeParameters)); + } + + public override string ToString() + { + var b = new StringBuilder("["); + b.Append(GetType().Name); + b.Append(' '); + b.Append(this.DeclaringType.ReflectionName); + b.Append('.'); + b.Append(this.Name); + if (this.TypeArguments.Count > 0) + { + b.Append('['); + for (var i = 0; i < this.TypeArguments.Count; i++) + { + if (i > 0) + b.Append(", "); + b.Append(this.TypeArguments[i].ToString()); + } + b.Append(']'); + } + else if (this.TypeParameters.Count > 0) + { + b.Append("``"); + b.Append(this.TypeParameters.Count); + } + b.Append('('); + for (var i = 0; i < this.Parameters.Count; i++) + { + if (i > 0) + b.Append(", "); + b.Append(this.Parameters[i].ToString()); + } + b.Append("):"); + b.Append(this.ReturnType.ToString()); + b.Append(']'); + return b.ToString(); + } + + sealed class SpecializedTypeParameter : AbstractTypeParameter + { + readonly ITypeParameter baseTp; + + // The substition is set at the end of SpecializedMethod constructor + internal TypeVisitor substitution; + + public SpecializedTypeParameter(ITypeParameter baseTp, IMethod specializedOwner) + : base(specializedOwner, baseTp.Index, baseTp.Name, baseTp.Variance) + { + // We don't have to consider already-specialized baseTps because + // we read the baseTp directly from the unpacked memberDefinition. + this.baseTp = baseTp; + } + + public override IEnumerable GetAttributes() => baseTp.GetAttributes(); + + public override int GetHashCode() + { + return baseTp.GetHashCode() ^ this.Owner.GetHashCode(); + } + + public override bool Equals(IType other) + { + // Compare the owner, not the substitution, because the substitution may contain this specialized type parameter recursively + var o = other as SpecializedTypeParameter; + return o != null && baseTp.Equals(o.baseTp) && this.Owner.Equals(o.Owner); + } + + public override bool HasValueTypeConstraint => baseTp.HasValueTypeConstraint; + public override bool HasReferenceTypeConstraint => baseTp.HasReferenceTypeConstraint; + public override bool HasDefaultConstructorConstraint => baseTp.HasDefaultConstructorConstraint; + public override bool HasUnmanagedConstraint => baseTp.HasUnmanagedConstraint; + + public override Nullability NullabilityConstraint => baseTp.NullabilityConstraint; + + IReadOnlyList typeConstraints; + + public override IReadOnlyList TypeConstraints { + get { + var typeConstraints = LazyInit.VolatileRead(ref this.typeConstraints); + if (typeConstraints == null) + { + typeConstraints = baseTp.TypeConstraints.SelectReadOnlyArray(c => new TypeConstraint(c.Type.AcceptVisitor(substitution), c.Attributes)); + typeConstraints = LazyInit.GetOrSet(ref this.typeConstraints, typeConstraints); + } + return typeConstraints; + } + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedParameter.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedParameter.cs new file mode 100644 index 0000000..2c3fa6a --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedParameter.cs @@ -0,0 +1,59 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Diagnostics; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + sealed class SpecializedParameter : IParameter + { + readonly IParameter baseParameter; + readonly IType newType; + readonly IParameterizedMember newOwner; + + public SpecializedParameter(IParameter baseParameter, IType newType, IParameterizedMember newOwner) + { + Debug.Assert(baseParameter != null && newType != null); + this.baseParameter = baseParameter; + this.newType = newType; + this.newOwner = newOwner; + } + + IEnumerable IParameter.GetAttributes() => baseParameter.GetAttributes(); + ReferenceKind IParameter.ReferenceKind => baseParameter.ReferenceKind; + bool IParameter.IsRef => baseParameter.IsRef; + bool IParameter.IsOut => baseParameter.IsOut; + bool IParameter.IsIn => baseParameter.IsIn; + bool IParameter.IsParams => baseParameter.IsParams; + bool IParameter.IsOptional => baseParameter.IsOptional; + bool IParameter.HasConstantValueInSignature => baseParameter.HasConstantValueInSignature; + IParameterizedMember IParameter.Owner => newOwner; + string IVariable.Name => baseParameter.Name; + string ISymbol.Name => baseParameter.Name; + IType IVariable.Type => newType; + bool IVariable.IsConst => baseParameter.IsConst; + object IVariable.GetConstantValue(bool throwOnInvalidMetadata) => baseParameter.GetConstantValue(throwOnInvalidMetadata); + SymbolKind ISymbol.SymbolKind => SymbolKind.Parameter; + + public override string ToString() + { + return DefaultParameter.ToString(this); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedProperty.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedProperty.cs new file mode 100644 index 0000000..4fa3e49 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SpecializedProperty.cs @@ -0,0 +1,72 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Represents a specialized IProperty (property after type substitution). + /// + public class SpecializedProperty : SpecializedParameterizedMember, IProperty + { + internal static IProperty Create(IProperty propertyDefinition, TypeParameterSubstitution substitution) + { + if (TypeParameterSubstitution.Identity.Equals(substitution) || propertyDefinition.DeclaringType.TypeParameterCount == 0) + { + return propertyDefinition; + } + if (substitution.MethodTypeArguments != null && substitution.MethodTypeArguments.Count > 0) + substitution = new TypeParameterSubstitution(substitution.ClassTypeArguments, EmptyList.Instance); + return new SpecializedProperty(propertyDefinition, substitution); + } + + readonly IProperty propertyDefinition; + + public SpecializedProperty(IProperty propertyDefinition, TypeParameterSubstitution substitution) + : base(propertyDefinition) + { + this.propertyDefinition = propertyDefinition; + AddSubstitution(substitution); + } + + public bool CanGet { + get { return propertyDefinition.CanGet; } + } + + public bool CanSet { + get { return propertyDefinition.CanSet; } + } + + IMethod getter, setter; + + public IMethod Getter { + get { return WrapAccessor(ref this.getter, propertyDefinition.Getter); } + } + + public IMethod Setter { + get { return WrapAccessor(ref this.setter, propertyDefinition.Setter); } + } + + public bool IsIndexer { + get { return propertyDefinition.IsIndexer; } + } + + public bool ReturnTypeIsRefReadOnly => propertyDefinition.ReturnTypeIsRefReadOnly; + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SyntheticRangeIndexer.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SyntheticRangeIndexer.cs new file mode 100644 index 0000000..58e8ca0 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/SyntheticRangeIndexer.cs @@ -0,0 +1,142 @@ +// Copyright (c) 2020 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Synthetic method representing a compiler-generated indexer + /// with the signature 'get_Item(System.Index)' or 'get_Item(System.Range)'. + /// Can also be a setter. + /// Used for the "Implicit Index support"/"Implicit Range support" for the C# 8 ranges feature. + /// + class SyntheticRangeIndexAccessor : IMethod + { + /// + /// The underlying method: `get_Item(int)`, `set_Item(int, T)` or `Slice(int, int)`. + /// + readonly IMethod underlyingMethod; + readonly IType indexOrRangeType; + readonly IReadOnlyList parameters; + readonly bool slicing; + + public SyntheticRangeIndexAccessor(IMethod underlyingMethod, IType indexOrRangeType, bool slicing) + { + Debug.Assert(underlyingMethod != null); + Debug.Assert(indexOrRangeType != null); + this.underlyingMethod = underlyingMethod; + this.indexOrRangeType = indexOrRangeType; + this.slicing = slicing; + var parameters = new List(); + parameters.Add(new DefaultParameter(indexOrRangeType, "")); + if (slicing) + { + Debug.Assert(underlyingMethod.Parameters.Count == 2); + } + else + { + parameters.AddRange(underlyingMethod.Parameters.Skip(1)); + } + this.parameters = parameters; + } + + public bool IsSlicing => slicing; + + bool IMethod.ReturnTypeIsRefReadOnly => underlyingMethod.ReturnTypeIsRefReadOnly; + bool IMethod.ThisIsRefReadOnly => underlyingMethod.ThisIsRefReadOnly; + bool IMethod.IsInitOnly => underlyingMethod.IsInitOnly; + + IReadOnlyList IMethod.TypeParameters => EmptyList.Instance; + IReadOnlyList IMethod.TypeArguments => EmptyList.Instance; + + bool IMethod.IsExtensionMethod => false; + bool IMethod.IsLocalFunction => false; + bool IMethod.IsConstructor => false; + bool IMethod.IsDestructor => false; + bool IMethod.IsOperator => false; + bool IMethod.HasBody => underlyingMethod.HasBody; + bool IMethod.IsAccessor => underlyingMethod.IsAccessor; + IMember IMethod.AccessorOwner => underlyingMethod.AccessorOwner; + MethodSemanticsAttributes IMethod.AccessorKind => underlyingMethod.AccessorKind; + IMethod IMethod.ReducedFrom => underlyingMethod.ReducedFrom; + IReadOnlyList IParameterizedMember.Parameters => parameters; + IMember IMember.MemberDefinition => underlyingMethod.MemberDefinition; + IType IMember.ReturnType => underlyingMethod.ReturnType; + IEnumerable IMember.ExplicitlyImplementedInterfaceMembers => EmptyList.Instance; + bool IMember.IsExplicitInterfaceImplementation => false; + bool IMember.IsVirtual => underlyingMethod.IsVirtual; + bool IMember.IsOverride => underlyingMethod.IsOverride; + bool IMember.IsOverridable => underlyingMethod.IsOverridable; + TypeParameterSubstitution IMember.Substitution => underlyingMethod.Substitution; + EntityHandle IEntity.MetadataToken => underlyingMethod.MetadataToken; + public string Name => underlyingMethod.Name; + IType IEntity.DeclaringType => underlyingMethod.DeclaringType; + ITypeDefinition IEntity.DeclaringTypeDefinition => underlyingMethod.DeclaringTypeDefinition; + IModule IEntity.ParentModule => underlyingMethod.ParentModule; + Accessibility IEntity.Accessibility => underlyingMethod.Accessibility; + bool IEntity.IsStatic => underlyingMethod.IsStatic; + bool IEntity.IsAbstract => underlyingMethod.IsAbstract; + bool IEntity.IsSealed => underlyingMethod.IsSealed; + SymbolKind ISymbol.SymbolKind => SymbolKind.Method; + ICompilation ICompilationProvider.Compilation => underlyingMethod.Compilation; + string INamedElement.FullName => underlyingMethod.FullName; + string INamedElement.ReflectionName => underlyingMethod.ReflectionName; + string INamedElement.Namespace => underlyingMethod.Namespace; + + public override bool Equals(object obj) + { + return obj is SyntheticRangeIndexAccessor g + && this.underlyingMethod.Equals(g.underlyingMethod) + && this.indexOrRangeType.Equals(g.indexOrRangeType) + && this.slicing == g.slicing; + } + + public override int GetHashCode() + { + return underlyingMethod.GetHashCode() ^ indexOrRangeType.GetHashCode(); + } + + bool IMember.Equals(IMember obj, TypeVisitor typeNormalization) + { + return obj is SyntheticRangeIndexAccessor g + && this.underlyingMethod.Equals(g.underlyingMethod, typeNormalization) + && this.indexOrRangeType.AcceptVisitor(typeNormalization).Equals(g.indexOrRangeType.AcceptVisitor(typeNormalization)); + } + + IEnumerable IEntity.GetAttributes() => underlyingMethod.GetAttributes(); + + IEnumerable IMethod.GetReturnTypeAttributes() => underlyingMethod.GetReturnTypeAttributes(); + + IMethod IMethod.Specialize(TypeParameterSubstitution substitution) + { + return new SyntheticRangeIndexAccessor(underlyingMethod.Specialize(substitution), indexOrRangeType, slicing); + } + + IMember IMember.Specialize(TypeParameterSubstitution substitution) + { + return new SyntheticRangeIndexAccessor(underlyingMethod.Specialize(substitution), indexOrRangeType, slicing); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/ThreeState.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/ThreeState.cs new file mode 100644 index 0000000..6b679f3 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/ThreeState.cs @@ -0,0 +1,33 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Constants used instead of bool? + /// in multithreaded code, as bool? might produce torn reads. + /// + static class ThreeState + { + public const byte Unknown = 0; + public const byte False = 1; + public const byte True = 2; + + public static byte From(bool value) => value ? True : False; + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/TypeParameterReference.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/TypeParameterReference.cs new file mode 100644 index 0000000..466a512 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/TypeParameterReference.cs @@ -0,0 +1,103 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Globalization; + +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + [Serializable] + public sealed class TypeParameterReference : ITypeReference + { + static readonly TypeParameterReference[] classTypeParameterReferences = new TypeParameterReference[8]; + static readonly TypeParameterReference[] methodTypeParameterReferences = new TypeParameterReference[8]; + + /// + /// Creates a type parameter reference. + /// For common type parameter references, this method may return a shared instance. + /// + public static TypeParameterReference Create(SymbolKind ownerType, int index) + { + if (index >= 0 && index < 8 && (ownerType == SymbolKind.TypeDefinition || ownerType == SymbolKind.Method)) + { + var arr = (ownerType == SymbolKind.TypeDefinition) ? classTypeParameterReferences : methodTypeParameterReferences; + var result = LazyInit.VolatileRead(ref arr[index]); + if (result == null) + { + result = LazyInit.GetOrSet(ref arr[index], new TypeParameterReference(ownerType, index)); + } + return result; + } + else + { + return new TypeParameterReference(ownerType, index); + } + } + + readonly SymbolKind ownerType; + readonly int index; + + public int Index { + get { + return index; + } + } + + public TypeParameterReference(SymbolKind ownerType, int index) + { + this.ownerType = ownerType; + this.index = index; + } + + public IType Resolve(ITypeResolveContext context) + { + if (ownerType == SymbolKind.Method) + { + var method = context.CurrentMember as IMethod; + if (method != null && index < method.TypeParameters.Count) + { + return method.TypeParameters[index]; + } + return DummyTypeParameter.GetMethodTypeParameter(index); + } + else if (ownerType == SymbolKind.TypeDefinition) + { + var typeDef = context.CurrentTypeDefinition; + if (typeDef != null && index < typeDef.TypeParameters.Count) + { + return typeDef.TypeParameters[index]; + } + return DummyTypeParameter.GetClassTypeParameter(index); + } + else + { + return SpecialType.UnknownType; + } + } + + public override string ToString() + { + if (ownerType == SymbolKind.Method) + return "!!" + index.ToString(CultureInfo.InvariantCulture); + else + return "!" + index.ToString(CultureInfo.InvariantCulture); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/TypeWithElementType.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/TypeWithElementType.cs new file mode 100644 index 0000000..1b3d9f0 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/TypeWithElementType.cs @@ -0,0 +1,65 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + public abstract class TypeWithElementType : AbstractType + { + protected IType elementType; + + protected TypeWithElementType(IType elementType) + { + if (elementType == null) + throw new ArgumentNullException(nameof(elementType)); + this.elementType = elementType; + } + + public override string Name { + get { return elementType.Name + NameSuffix; } + } + + public override string Namespace { + get { return elementType.Namespace; } + } + + public override string FullName { + get { return elementType.FullName + NameSuffix; } + } + + public override string ReflectionName { + get { return elementType.ReflectionName + NameSuffix; } + } + + public override string ToString() + { + return elementType.ToString() + NameSuffix; + } + + public abstract string NameSuffix { get; } + + public IType ElementType { + get { return elementType; } + } + + // Force concrete implementations to override VisitChildren - the base implementation + // in AbstractType assumes there are no children, but we know there is (at least) 1. + public abstract override IType VisitChildren(TypeVisitor visitor); + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Implementation/UnknownType.cs b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/UnknownType.cs new file mode 100644 index 0000000..9a33e69 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Implementation/UnknownType.cs @@ -0,0 +1,129 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Diagnostics; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// An unknown type where (part) of the name is known. + /// + [Serializable] + public class UnknownType : AbstractType, ITypeReference + { + readonly bool namespaceKnown; + readonly FullTypeName fullTypeName; + readonly bool? isReferenceType = null; + + /// + /// Creates a new unknown type. + /// + /// Namespace name, if known. Can be null if unknown. + /// Name of the type, must not be null. + /// Type parameter count, zero if unknown. + public UnknownType(string namespaceName, string name, int typeParameterCount = 0, bool? isReferenceType = null) + { + if (name == null) + throw new ArgumentNullException(nameof(name)); + this.namespaceKnown = namespaceName != null; + this.fullTypeName = new TopLevelTypeName(namespaceName ?? string.Empty, name, typeParameterCount); + this.isReferenceType = isReferenceType; + } + + /// + /// Creates a new unknown type. + /// + /// Full name of the unknown type. + public UnknownType(FullTypeName fullTypeName, bool? isReferenceType = null) + { + this.isReferenceType = isReferenceType; + if (fullTypeName.Name == null) + { + Debug.Assert(fullTypeName == default(FullTypeName)); + this.namespaceKnown = false; + this.fullTypeName = new TopLevelTypeName(string.Empty, "?", 0); + } + else + { + this.namespaceKnown = true; + this.fullTypeName = fullTypeName; + } + } + + public override TypeKind Kind { + get { return TypeKind.Unknown; } + } + + IType ITypeReference.Resolve(ITypeResolveContext context) + { + if (context == null) + throw new ArgumentNullException(nameof(context)); + return this; + } + + public override string Name { + get { return fullTypeName.Name; } + } + + public override string Namespace { + get { return fullTypeName.TopLevelTypeName.Namespace; } + } + + public override string ReflectionName { + get { return namespaceKnown ? fullTypeName.ReflectionName : "?"; } + } + + public FullTypeName FullTypeName => fullTypeName; + + public override int TypeParameterCount => fullTypeName.TypeParameterCount; + public override IReadOnlyList TypeParameters => DummyTypeParameter.GetClassTypeParameterList(TypeParameterCount); + public override IReadOnlyList TypeArguments => TypeParameters; + + public override bool? IsReferenceType { + get { return isReferenceType; } + } + + public override IType ChangeNullability(Nullability nullability) + { + if (nullability == Nullability.Oblivious) + return this; + else + return new NullabilityAnnotatedType(this, nullability); + } + + public override int GetHashCode() + { + return (namespaceKnown ? 812571 : 12651) ^ fullTypeName.GetHashCode(); + } + + public override bool Equals(IType other) + { + var o = other as UnknownType; + if (o == null) + return false; + return this.namespaceKnown == o.namespaceKnown && this.fullTypeName == o.fullTypeName && this.isReferenceType == o.isReferenceType; + } + + public override string ToString() + { + return "[UnknownType " + fullTypeName.ReflectionName + "]"; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/InheritanceHelper.cs b/src/ICSharpCode.Decompiler/TypeSystem/InheritanceHelper.cs new file mode 100644 index 0000000..94fd694 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/InheritanceHelper.cs @@ -0,0 +1,207 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Provides helper methods for inheritance. + /// + public static class InheritanceHelper + { + // TODO: maybe these should be extension methods? + // or even part of the interface itself? (would allow for easy caching) + + #region GetBaseMember + /// + /// Gets the base member that has the same signature. + /// + public static IMember GetBaseMember(IMember member) + { + return GetBaseMembers(member, false).FirstOrDefault(); + } + + /// + /// Gets all base members that have the same signature. + /// + /// + /// List of base members with the same signature. The member from the derived-most base class is returned first. + /// + public static IEnumerable GetBaseMembers(IMember member, bool includeImplementedInterfaces) + { + if (member == null) + throw new ArgumentNullException(nameof(member)); + + if (includeImplementedInterfaces) + { + if (member.IsExplicitInterfaceImplementation && member.ExplicitlyImplementedInterfaceMembers.Count() == 1) + { + // C#-style explicit interface implementation + member = member.ExplicitlyImplementedInterfaceMembers.First(); + yield return member; + } + } + + // Remove generic specialization + var substitution = member.Substitution; + member = member.MemberDefinition; + + if (member.DeclaringTypeDefinition == null) + { + // For global methods, return empty list. (prevent SharpDevelop UDC crash 4524) + yield break; + } + + IEnumerable allBaseTypes; + if (includeImplementedInterfaces) + { + allBaseTypes = member.DeclaringTypeDefinition.GetAllBaseTypes(); + } + else + { + allBaseTypes = member.DeclaringTypeDefinition.GetNonInterfaceBaseTypes(); + } + foreach (var baseType in allBaseTypes.Reverse()) + { + if (baseType == member.DeclaringTypeDefinition) + continue; + + IEnumerable baseMembers; + if (member.SymbolKind == SymbolKind.Accessor) + { + baseMembers = baseType.GetAccessors(m => m.Name == member.Name && m.Accessibility > Accessibility.Private, GetMemberOptions.IgnoreInheritedMembers); + } + else + { + baseMembers = baseType.GetMembers(m => m.Name == member.Name && m.Accessibility > Accessibility.Private, GetMemberOptions.IgnoreInheritedMembers); + } + foreach (var baseMember in baseMembers) + { + System.Diagnostics.Debug.Assert(baseMember.Accessibility != Accessibility.Private); + if (SignatureComparer.Ordinal.Equals(member, baseMember)) + { + yield return baseMember.Specialize(substitution); + } + } + } + } + #endregion + + #region GetDerivedMember + /// + /// Finds the member declared in 'derivedType' that has the same signature (could override) 'baseMember'. + /// + public static IMember GetDerivedMember(IMember baseMember, ITypeDefinition derivedType) + { + if (baseMember == null) + throw new ArgumentNullException(nameof(baseMember)); + if (derivedType == null) + throw new ArgumentNullException(nameof(derivedType)); + + if (baseMember.Compilation != derivedType.Compilation) + throw new ArgumentException("baseMember and derivedType must be from the same compilation"); + + baseMember = baseMember.MemberDefinition; + var includeInterfaces = baseMember.DeclaringTypeDefinition.Kind == TypeKind.Interface; + var method = baseMember as IMethod; + if (method != null) + { + foreach (var derivedMethod in derivedType.Methods) + { + if (derivedMethod.Name == method.Name && derivedMethod.Parameters.Count == method.Parameters.Count) + { + if (derivedMethod.TypeParameters.Count == method.TypeParameters.Count) + { + // The method could override the base method: + if (GetBaseMembers(derivedMethod, includeInterfaces).Any(m => m.MemberDefinition == baseMember)) + return derivedMethod; + } + } + } + } + var property = baseMember as IProperty; + if (property != null) + { + foreach (var derivedProperty in derivedType.Properties) + { + if (derivedProperty.Name == property.Name && derivedProperty.Parameters.Count == property.Parameters.Count) + { + // The property could override the base property: + if (GetBaseMembers(derivedProperty, includeInterfaces).Any(m => m.MemberDefinition == baseMember)) + return derivedProperty; + } + } + } + if (baseMember is IEvent) + { + foreach (var derivedEvent in derivedType.Events) + { + if (derivedEvent.Name == baseMember.Name) + return derivedEvent; + } + } + if (baseMember is IField) + { + foreach (var derivedField in derivedType.Fields) + { + if (derivedField.Name == baseMember.Name) + return derivedField; + } + } + return null; + } + #endregion + + #region Attributes + internal static IEnumerable GetAttributes(ITypeDefinition typeDef) + { + foreach (var baseType in typeDef.GetNonInterfaceBaseTypes().Reverse()) + { + var baseTypeDef = baseType.GetDefinition(); + if (baseTypeDef == null) + continue; + foreach (var attr in baseTypeDef.GetAttributes()) + { + yield return attr; + } + } + } + + internal static IEnumerable GetAttributes(IMember member) + { + var visitedMembers = new HashSet(); + do + { + member = member.MemberDefinition; // it's sufficient to look at the definitions + if (!visitedMembers.Add(member)) + { + // abort if we seem to be in an infinite loop (cyclic inheritance) + break; + } + foreach (var attr in member.GetAttributes()) + { + yield return attr; + } + } while (member.IsOverride && (member = InheritanceHelper.GetBaseMember(member)) != null); + } + #endregion + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/IntersectionType.cs b/src/ICSharpCode.Decompiler/TypeSystem/IntersectionType.cs new file mode 100644 index 0000000..4a3dbfc --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/IntersectionType.cs @@ -0,0 +1,181 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Diagnostics; +using System.Linq; +using System.Text; + +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Represents the intersection of several types. + /// + public class IntersectionType : AbstractType + { + readonly ReadOnlyCollection types; + + public ReadOnlyCollection Types { + get { return types; } + } + + private IntersectionType(IType[] types) + { + Debug.Assert(types.Length >= 2); + this.types = Array.AsReadOnly(types); + } + + public static IType Create(IEnumerable types) + { + var arr = types.Distinct().ToArray(); + foreach (var type in arr) + { + if (type == null) + throw new ArgumentNullException(); + } + if (arr.Length == 0) + return SpecialType.UnknownType; + else if (arr.Length == 1) + return arr[0]; + else + return new IntersectionType(arr); + } + + public override TypeKind Kind { + get { return TypeKind.Intersection; } + } + + public override string Name { + get { + var b = new StringBuilder(); + foreach (var t in types) + { + if (b.Length > 0) + b.Append(" & "); + b.Append(t.Name); + } + return b.ToString(); + } + } + + public override string ReflectionName { + get { + var b = new StringBuilder(); + foreach (var t in types) + { + if (b.Length > 0) + b.Append(" & "); + b.Append(t.ReflectionName); + } + return b.ToString(); + } + } + + public override bool? IsReferenceType { + get { + foreach (var t in types) + { + var isReferenceType = t.IsReferenceType; + if (isReferenceType.HasValue) + return isReferenceType.Value; + } + return null; + } + } + + public override int GetHashCode() + { + var hashCode = 0; + unchecked + { + foreach (var t in types) + { + hashCode *= 7137517; + hashCode += t.GetHashCode(); + } + } + return hashCode; + } + + public override bool Equals(IType other) + { + var o = other as IntersectionType; + if (o != null && types.Count == o.types.Count) + { + for (var i = 0; i < types.Count; i++) + { + if (!types[i].Equals(o.types[i])) + return false; + } + return true; + } + return false; + } + + public override IEnumerable DirectBaseTypes { + get { return types; } + } + + public override IEnumerable GetMethods(Predicate filter, GetMemberOptions options) + { + return GetMembersHelper.GetMethods(this, FilterNonStatic(filter), options); + } + + public override IEnumerable GetMethods(IReadOnlyList typeArguments, Predicate filter, GetMemberOptions options) + { + return GetMembersHelper.GetMethods(this, typeArguments, filter, options); + } + + public override IEnumerable GetProperties(Predicate filter, GetMemberOptions options) + { + return GetMembersHelper.GetProperties(this, FilterNonStatic(filter), options); + } + + public override IEnumerable GetFields(Predicate filter, GetMemberOptions options) + { + return GetMembersHelper.GetFields(this, FilterNonStatic(filter), options); + } + + public override IEnumerable GetEvents(Predicate filter, GetMemberOptions options) + { + return GetMembersHelper.GetEvents(this, FilterNonStatic(filter), options); + } + + public override IEnumerable GetMembers(Predicate filter, GetMemberOptions options) + { + return GetMembersHelper.GetMembers(this, FilterNonStatic(filter), options); + } + + public override IEnumerable GetAccessors(Predicate filter, GetMemberOptions options) + { + return GetMembersHelper.GetAccessors(this, FilterNonStatic(filter), options); + } + + static Predicate FilterNonStatic(Predicate filter) where T : class, IMember + { + if (filter == null) + return member => !member.IsStatic; + else + return member => !member.IsStatic && filter(member); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/KnownTypeReference.cs b/src/ICSharpCode.Decompiler/TypeSystem/KnownTypeReference.cs new file mode 100644 index 0000000..281e675 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/KnownTypeReference.cs @@ -0,0 +1,343 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Represents some well-known types. + /// + public enum KnownTypeCode + { + // Note: DefaultResolvedTypeDefinition uses (KnownTypeCode)-1 as special value for "not yet calculated". + // The order of type codes at the beginning must correspond to those in System.TypeCode. + + /// + /// Not one of the known types. + /// + None, + /// object (System.Object) + Object, + /// System.DBNull + DBNull, + /// bool (System.Boolean) + Boolean, + /// char (System.Char) + Char, + /// sbyte (System.SByte) + SByte, + /// byte (System.Byte) + Byte, + /// short (System.Int16) + Int16, + /// ushort (System.UInt16) + UInt16, + /// int (System.Int32) + Int32, + /// uint (System.UInt32) + UInt32, + /// long (System.Int64) + Int64, + /// ulong (System.UInt64) + UInt64, + /// float (System.Single) + Single, + /// double (System.Double) + Double, + /// decimal (System.Decimal) + Decimal, + /// System.DateTime + DateTime, + /// string (System.String) + String = 18, + + // String was the last element from System.TypeCode, now our additional known types start + + /// void (System.Void) + Void, + /// System.Type + Type, + /// System.Array + Array, + /// System.Attribute + Attribute, + /// System.ValueType + ValueType, + /// System.Enum + Enum, + /// System.Delegate + Delegate, + /// System.MulticastDelegate + MulticastDelegate, + /// System.Exception + Exception, + /// System.IntPtr + IntPtr, + /// System.UIntPtr + UIntPtr, + /// System.Collections.IEnumerable + IEnumerable, + /// System.Collections.IEnumerator + IEnumerator, + /// System.Collections.Generic.IEnumerable{T} + IEnumerableOfT, + /// System.Collections.Generic.IEnumerator{T} + IEnumeratorOfT, + /// System.Collections.Generic.ICollection + ICollection, + /// System.Collections.Generic.ICollection{T} + ICollectionOfT, + /// System.Collections.Generic.IList + IList, + /// System.Collections.Generic.IList{T} + IListOfT, + /// System.Collections.Generic.IReadOnlyCollection{T} + IReadOnlyCollectionOfT, + /// System.Collections.Generic.IReadOnlyList{T} + IReadOnlyListOfT, + /// System.Threading.Tasks.Task + Task, + /// System.Threading.Tasks.Task{T} + TaskOfT, + /// System.Threading.Tasks.ValueTask + ValueTask, + /// System.Threading.Tasks.ValueTask{T} + ValueTaskOfT, + /// System.Nullable{T} + NullableOfT, + /// System.IDisposable + IDisposable, + /// System.IAsyncDisposable + IAsyncDisposable, + /// System.Runtime.CompilerServices.INotifyCompletion + INotifyCompletion, + /// System.Runtime.CompilerServices.ICriticalNotifyCompletion + ICriticalNotifyCompletion, + /// System.TypedReference + TypedReference, + /// System.IFormattable + IFormattable, + /// System.FormattableString + FormattableString, + /// System.Span{T} + SpanOfT, + /// System.ReadOnlySpan{T} + ReadOnlySpanOfT, + /// System.Memory{T} + MemoryOfT, + /// System.Runtime.CompilerServices.Unsafe + Unsafe, + /// System.Collections.Generic.IAsyncEnumerable{T} + IAsyncEnumerableOfT, + /// System.Collections.Generic.IAsyncEnumerator{T} + IAsyncEnumeratorOfT, + /// System.Index + Index, + /// System.Range + Range + } + + /// + /// Contains well-known type references. + /// + [Serializable] + public sealed class KnownTypeReference : ITypeReference + { + internal const int KnownTypeCodeCount = (int)KnownTypeCode.Range + 1; + + static readonly KnownTypeReference[] knownTypeReferences = new KnownTypeReference[KnownTypeCodeCount] { + null, // None + new KnownTypeReference(KnownTypeCode.Object, TypeKind.Class, "System", "Object", baseType: KnownTypeCode.None), + new KnownTypeReference(KnownTypeCode.DBNull, TypeKind.Class, "System", "DBNull"), + new KnownTypeReference(KnownTypeCode.Boolean, TypeKind.Struct, "System", "Boolean"), + new KnownTypeReference(KnownTypeCode.Char, TypeKind.Struct, "System", "Char"), + new KnownTypeReference(KnownTypeCode.SByte, TypeKind.Struct, "System", "SByte"), + new KnownTypeReference(KnownTypeCode.Byte, TypeKind.Struct, "System", "Byte"), + new KnownTypeReference(KnownTypeCode.Int16, TypeKind.Struct, "System", "Int16"), + new KnownTypeReference(KnownTypeCode.UInt16, TypeKind.Struct, "System", "UInt16"), + new KnownTypeReference(KnownTypeCode.Int32, TypeKind.Struct, "System", "Int32"), + new KnownTypeReference(KnownTypeCode.UInt32, TypeKind.Struct, "System", "UInt32"), + new KnownTypeReference(KnownTypeCode.Int64, TypeKind.Struct, "System", "Int64"), + new KnownTypeReference(KnownTypeCode.UInt64, TypeKind.Struct, "System", "UInt64"), + new KnownTypeReference(KnownTypeCode.Single, TypeKind.Struct, "System", "Single"), + new KnownTypeReference(KnownTypeCode.Double, TypeKind.Struct, "System", "Double"), + new KnownTypeReference(KnownTypeCode.Decimal, TypeKind.Struct, "System", "Decimal"), + new KnownTypeReference(KnownTypeCode.DateTime, TypeKind.Struct, "System", "DateTime"), + null, + new KnownTypeReference(KnownTypeCode.String, TypeKind.Class, "System", "String"), + new KnownTypeReference(KnownTypeCode.Void, TypeKind.Void, "System", "Void", baseType: KnownTypeCode.ValueType), + new KnownTypeReference(KnownTypeCode.Type, TypeKind.Class, "System", "Type"), + new KnownTypeReference(KnownTypeCode.Array, TypeKind.Class, "System", "Array"), + new KnownTypeReference(KnownTypeCode.Attribute, TypeKind.Class, "System", "Attribute"), + new KnownTypeReference(KnownTypeCode.ValueType, TypeKind.Class, "System", "ValueType"), + new KnownTypeReference(KnownTypeCode.Enum, TypeKind.Class, "System", "Enum", baseType: KnownTypeCode.ValueType), + new KnownTypeReference(KnownTypeCode.Delegate, TypeKind.Class, "System", "Delegate"), + new KnownTypeReference(KnownTypeCode.MulticastDelegate, TypeKind.Class, "System", "MulticastDelegate", baseType: KnownTypeCode.Delegate), + new KnownTypeReference(KnownTypeCode.Exception, TypeKind.Class, "System", "Exception"), + new KnownTypeReference(KnownTypeCode.IntPtr, TypeKind.Struct, "System", "IntPtr"), + new KnownTypeReference(KnownTypeCode.UIntPtr, TypeKind.Struct, "System", "UIntPtr"), + new KnownTypeReference(KnownTypeCode.IEnumerable, TypeKind.Interface, "System.Collections", "IEnumerable"), + new KnownTypeReference(KnownTypeCode.IEnumerator, TypeKind.Interface, "System.Collections", "IEnumerator"), + new KnownTypeReference(KnownTypeCode.IEnumerableOfT, TypeKind.Interface, "System.Collections.Generic", "IEnumerable", 1), + new KnownTypeReference(KnownTypeCode.IEnumeratorOfT, TypeKind.Interface, "System.Collections.Generic", "IEnumerator", 1), + new KnownTypeReference(KnownTypeCode.ICollection, TypeKind.Interface, "System.Collections", "ICollection"), + new KnownTypeReference(KnownTypeCode.ICollectionOfT, TypeKind.Interface, "System.Collections.Generic", "ICollection", 1), + new KnownTypeReference(KnownTypeCode.IList, TypeKind.Interface, "System.Collections", "IList"), + new KnownTypeReference(KnownTypeCode.IListOfT, TypeKind.Interface, "System.Collections.Generic", "IList", 1), + + new KnownTypeReference(KnownTypeCode.IReadOnlyCollectionOfT, TypeKind.Interface, "System.Collections.Generic", "IReadOnlyCollection", 1), + new KnownTypeReference(KnownTypeCode.IReadOnlyListOfT, TypeKind.Interface, "System.Collections.Generic", "IReadOnlyList", 1), + new KnownTypeReference(KnownTypeCode.Task, TypeKind.Class, "System.Threading.Tasks", "Task"), + new KnownTypeReference(KnownTypeCode.TaskOfT, TypeKind.Class, "System.Threading.Tasks", "Task", 1, baseType: KnownTypeCode.Task), + new KnownTypeReference(KnownTypeCode.ValueTask, TypeKind.Struct, "System.Threading.Tasks", "ValueTask"), + new KnownTypeReference(KnownTypeCode.ValueTaskOfT, TypeKind.Struct, "System.Threading.Tasks", "ValueTask", 1), + new KnownTypeReference(KnownTypeCode.NullableOfT, TypeKind.Struct, "System", "Nullable", 1), + new KnownTypeReference(KnownTypeCode.IDisposable, TypeKind.Interface, "System", "IDisposable"), + new KnownTypeReference(KnownTypeCode.IAsyncDisposable, TypeKind.Interface, "System", "IAsyncDisposable"), + new KnownTypeReference(KnownTypeCode.INotifyCompletion, TypeKind.Interface, "System.Runtime.CompilerServices", "INotifyCompletion"), + new KnownTypeReference(KnownTypeCode.ICriticalNotifyCompletion, TypeKind.Interface, "System.Runtime.CompilerServices", "ICriticalNotifyCompletion"), + + new KnownTypeReference(KnownTypeCode.TypedReference, TypeKind.Struct, "System", "TypedReference"), + new KnownTypeReference(KnownTypeCode.IFormattable, TypeKind.Interface, "System", "IFormattable"), + new KnownTypeReference(KnownTypeCode.FormattableString, TypeKind.Class, "System", "FormattableString", baseType: KnownTypeCode.IFormattable), + new KnownTypeReference(KnownTypeCode.SpanOfT, TypeKind.Struct, "System", "Span", 1), + new KnownTypeReference(KnownTypeCode.ReadOnlySpanOfT, TypeKind.Struct, "System", "ReadOnlySpan", 1), + new KnownTypeReference(KnownTypeCode.MemoryOfT, TypeKind.Struct, "System", "Memory", 1), + new KnownTypeReference(KnownTypeCode.Unsafe, TypeKind.Class, "System.Runtime.CompilerServices", "Unsafe", 0), + new KnownTypeReference(KnownTypeCode.IAsyncEnumerableOfT, TypeKind.Interface, "System.Collections.Generic", "IAsyncEnumerable", 1), + new KnownTypeReference(KnownTypeCode.IAsyncEnumeratorOfT, TypeKind.Interface, "System.Collections.Generic", "IAsyncEnumerator", 1), + new KnownTypeReference(KnownTypeCode.Index, TypeKind.Struct, "System", "Index", 0), + new KnownTypeReference(KnownTypeCode.Range, TypeKind.Struct, "System", "Range", 0), + }; + + /// + /// Gets the known type reference for the specified type code. + /// Returns null for KnownTypeCode.None. + /// + public static KnownTypeReference Get(KnownTypeCode typeCode) + { + return knownTypeReferences[(int)typeCode]; + } + + public static IEnumerable AllKnownTypes { + get { + for (var i = 0; i < KnownTypeCodeCount; i++) + { + var ktr = Get((KnownTypeCode)i); + if (ktr == null) + continue; + yield return ktr; + } + } + } + + readonly KnownTypeCode knownTypeCode; + readonly string namespaceName; + readonly string name; + readonly int typeParameterCount; + internal readonly KnownTypeCode baseType; + internal readonly TypeKind typeKind; + + private KnownTypeReference(KnownTypeCode knownTypeCode, TypeKind typeKind, string namespaceName, string name, int typeParameterCount = 0, KnownTypeCode baseType = KnownTypeCode.Object) + { + if (typeKind == TypeKind.Struct && baseType == KnownTypeCode.Object) + baseType = KnownTypeCode.ValueType; + this.knownTypeCode = knownTypeCode; + this.namespaceName = namespaceName; + this.name = name; + this.typeParameterCount = typeParameterCount; + this.typeKind = typeKind; + this.baseType = baseType; + } + + public KnownTypeCode KnownTypeCode { + get { return knownTypeCode; } + } + + public string Namespace { + get { return namespaceName; } + } + + public string Name { + get { return name; } + } + + public int TypeParameterCount { + get { return typeParameterCount; } + } + + public TopLevelTypeName TypeName => new TopLevelTypeName(namespaceName, name, typeParameterCount); + + public IType Resolve(ITypeResolveContext context) + { + return context.Compilation.FindType(knownTypeCode); + } + + public override string ToString() + { + return GetCSharpNameByTypeCode(knownTypeCode) ?? (this.Namespace + "." + this.Name); + } + + /// + /// Gets the C# primitive type name from the known type code. + /// Returns null if there is no primitive name for the specified type. + /// + public static string GetCSharpNameByTypeCode(KnownTypeCode knownTypeCode) + { + switch (knownTypeCode) + { + case KnownTypeCode.Object: + return "object"; + case KnownTypeCode.Boolean: + return "bool"; + case KnownTypeCode.Char: + return "char"; + case KnownTypeCode.SByte: + return "sbyte"; + case KnownTypeCode.Byte: + return "byte"; + case KnownTypeCode.Int16: + return "short"; + case KnownTypeCode.UInt16: + return "ushort"; + case KnownTypeCode.Int32: + return "int"; + case KnownTypeCode.UInt32: + return "uint"; + case KnownTypeCode.Int64: + return "long"; + case KnownTypeCode.UInt64: + return "ulong"; + case KnownTypeCode.Single: + return "float"; + case KnownTypeCode.Double: + return "double"; + case KnownTypeCode.Decimal: + return "decimal"; + case KnownTypeCode.String: + return "string"; + case KnownTypeCode.Void: + return "void"; + default: + return null; + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/MetadataModule.cs b/src/ICSharpCode.Decompiler/TypeSystem/MetadataModule.cs new file mode 100644 index 0000000..038b29b --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/MetadataModule.cs @@ -0,0 +1,917 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Linq; +using System.Reflection; +using System.Reflection.Metadata; +using System.Reflection.Metadata.Ecma335; + +using ICSharpCode.Decompiler.Metadata; +using ICSharpCode.Decompiler.TypeSystem.Implementation; +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Type system implementation for Metadata.PEFile. + /// + [DebuggerDisplay("")] + public class MetadataModule : IModule + { + public ICompilation Compilation { get; } + internal readonly MetadataReader metadata; + internal readonly TypeProvider TypeProvider; + internal readonly Nullability NullableContext; + + readonly MetadataNamespace rootNamespace; + readonly MetadataTypeDefinition[] typeDefs; + readonly MetadataField[] fieldDefs; + readonly MetadataMethod[] methodDefs; + readonly MetadataProperty[] propertyDefs; + readonly MetadataEvent[] eventDefs; + readonly IModule[] referencedAssemblies; + + internal MetadataModule(ICompilation compilation, Metadata.PEFile peFile) + { + this.Compilation = compilation; + this.PEFile = peFile; + this.metadata = peFile.Metadata; + this.TypeProvider = new TypeProvider(this); + + // assembly metadata + if (metadata.IsAssembly) + { + var asmdef = metadata.GetAssemblyDefinition(); + try + { + this.AssemblyName = metadata.GetString(asmdef.Name); + this.FullAssemblyName = metadata.GetFullAssemblyName(); + } + catch (BadImageFormatException) + { + this.AssemblyName = ""; + this.FullAssemblyName = ""; + } + } + else + { + try + { + var moddef = metadata.GetModuleDefinition(); + this.AssemblyName = metadata.GetString(moddef.Name); + } + catch (BadImageFormatException) + { + this.AssemblyName = ""; + } + this.FullAssemblyName = this.AssemblyName; + } + var customAttrs = metadata.GetModuleDefinition().GetCustomAttributes(); + this.NullableContext = customAttrs.GetNullableContext(metadata) ?? Nullability.Oblivious; + this.minAccessibilityForNRT = FindMinimumAccessibilityForNRT(metadata, customAttrs); + this.rootNamespace = new MetadataNamespace(this, null, string.Empty, metadata.GetNamespaceDefinitionRoot()); + + // create arrays for resolved entities, indexed by row index + this.typeDefs = new MetadataTypeDefinition[metadata.TypeDefinitions.Count + 1]; + this.fieldDefs = new MetadataField[metadata.FieldDefinitions.Count + 1]; + this.methodDefs = new MetadataMethod[metadata.MethodDefinitions.Count + 1]; + this.propertyDefs = new MetadataProperty[metadata.PropertyDefinitions.Count + 1]; + this.eventDefs = new MetadataEvent[metadata.EventDefinitions.Count + 1]; + this.referencedAssemblies = new IModule[metadata.AssemblyReferences.Count + 1]; + } + + internal string GetString(StringHandle name) + { + return metadata.GetString(name); + } + + #region IAssembly interface + public PEFile PEFile { get; } + + public bool IsMainModule => this == Compilation.MainModule; + + public string AssemblyName { get; } + public string FullAssemblyName { get; } + string ISymbol.Name => AssemblyName; + SymbolKind ISymbol.SymbolKind => SymbolKind.Module; + + public INamespace RootNamespace => rootNamespace; + + public IEnumerable TopLevelTypeDefinitions => TypeDefinitions.Where(td => td.DeclaringTypeDefinition == null); + + public ITypeDefinition GetTypeDefinition(TopLevelTypeName topLevelTypeName) + { + var typeDefHandle = PEFile.GetTypeDefinition(topLevelTypeName); + if (typeDefHandle.IsNil) + { + var forwarderHandle = PEFile.GetTypeForwarder(topLevelTypeName); + if (!forwarderHandle.IsNil) + { + var forwarder = metadata.GetExportedType(forwarderHandle); + return ResolveForwardedType(forwarder).GetDefinition(); + } + } + return GetDefinition(typeDefHandle); + } + #endregion + + #region InternalsVisibleTo + public bool InternalsVisibleTo(IModule module) + { + if (this == module) + return true; + foreach (var shortName in GetInternalsVisibleTo()) + { + if (string.Equals(module.AssemblyName, shortName, StringComparison.OrdinalIgnoreCase)) + return true; + } + return false; + } + + string[] internalsVisibleTo; + + string[] GetInternalsVisibleTo() + { + var result = LazyInit.VolatileRead(ref this.internalsVisibleTo); + if (result != null) + { + return result; + } + if (metadata.IsAssembly) + { + var list = new List(); + foreach (var attrHandle in metadata.GetAssemblyDefinition().GetCustomAttributes()) + { + var attr = metadata.GetCustomAttribute(attrHandle); + if (attr.IsKnownAttribute(metadata, KnownAttribute.InternalsVisibleTo)) + { + var attrValue = attr.DecodeValue(this.TypeProvider); + if (attrValue.FixedArguments.Length == 1) + { + if (attrValue.FixedArguments[0].Value is string s) + { + list.Add(GetShortName(s)); + } + } + } + } + result = list.ToArray(); + } + else + { + result = Empty.Array; + } + return LazyInit.GetOrSet(ref this.internalsVisibleTo, result); + } + + static string GetShortName(string fullAssemblyName) + { + if (fullAssemblyName == null) + return null; + var pos = fullAssemblyName.IndexOf(','); + if (pos < 0) + return fullAssemblyName; + else + return fullAssemblyName.Substring(0, pos); + } + #endregion + + #region GetDefinition + /// + /// Gets all types in the assembly, including nested types. + /// + public IEnumerable TypeDefinitions + { + get + { + foreach (var tdHandle in metadata.TypeDefinitions) + { + yield return GetDefinition(tdHandle); + } + } + } + + public ITypeDefinition GetDefinition(TypeDefinitionHandle handle) + { + if (handle.IsNil) + return null; + if (typeDefs == null) + return new MetadataTypeDefinition(this, handle); + var row = MetadataTokens.GetRowNumber(handle); + if (row >= typeDefs.Length) + HandleOutOfRange(handle); + var typeDef = LazyInit.VolatileRead(ref typeDefs[row]); + if (typeDef != null) + return typeDef; + typeDef = new MetadataTypeDefinition(this, handle); + return LazyInit.GetOrSet(ref typeDefs[row], typeDef); + } + + public IField GetDefinition(FieldDefinitionHandle handle) + { + if (handle.IsNil) + return null; + if (fieldDefs == null) + return new MetadataField(this, handle); + var row = MetadataTokens.GetRowNumber(handle); + if (row >= fieldDefs.Length) + HandleOutOfRange(handle); + var field = LazyInit.VolatileRead(ref fieldDefs[row]); + if (field != null) + return field; + field = new MetadataField(this, handle); + return LazyInit.GetOrSet(ref fieldDefs[row], field); + } + + public IMethod GetDefinition(MethodDefinitionHandle handle) + { + if (handle.IsNil) + return null; + if (methodDefs == null) + return new MetadataMethod(this, handle); + var row = MetadataTokens.GetRowNumber(handle); + Debug.Assert(row != 0); + if (row >= methodDefs.Length) + HandleOutOfRange(handle); + var method = LazyInit.VolatileRead(ref methodDefs[row]); + if (method != null) + return method; + method = new MetadataMethod(this, handle); + return LazyInit.GetOrSet(ref methodDefs[row], method); + } + + public IProperty GetDefinition(PropertyDefinitionHandle handle) + { + if (handle.IsNil) + return null; + if (propertyDefs == null) + return new MetadataProperty(this, handle); + var row = MetadataTokens.GetRowNumber(handle); + Debug.Assert(row != 0); + if (row >= methodDefs.Length) + HandleOutOfRange(handle); + var property = LazyInit.VolatileRead(ref propertyDefs[row]); + if (property != null) + return property; + property = new MetadataProperty(this, handle); + return LazyInit.GetOrSet(ref propertyDefs[row], property); + } + + public IEvent GetDefinition(EventDefinitionHandle handle) + { + if (handle.IsNil) + return null; + if (eventDefs == null) + return new MetadataEvent(this, handle); + var row = MetadataTokens.GetRowNumber(handle); + Debug.Assert(row != 0); + if (row >= methodDefs.Length) + HandleOutOfRange(handle); + var ev = LazyInit.VolatileRead(ref eventDefs[row]); + if (ev != null) + return ev; + ev = new MetadataEvent(this, handle); + return LazyInit.GetOrSet(ref eventDefs[row], ev); + } + + void HandleOutOfRange(EntityHandle handle) + { + throw new BadImageFormatException("Handle with invalid row number."); + } + #endregion + + #region Resolve Module + + public IModule ResolveModule(AssemblyReferenceHandle handle) + { + if (handle.IsNil) + return null; + + if (referencedAssemblies == null) + return ResolveModuleUncached(handle); + var row = MetadataTokens.GetRowNumber(handle); + + if (row < 0) + { + return null; + } + + if (row >= referencedAssemblies.Length) + HandleOutOfRange(handle); + var module = LazyInit.VolatileRead(ref referencedAssemblies[row]); + if (module != null) + return module; + module = ResolveModuleUncached(handle); + return LazyInit.GetOrSet(ref referencedAssemblies[row], module); + } + + IModule ResolveModuleUncached(AssemblyReferenceHandle handle) + { + var asmRef = new Metadata.AssemblyReference(metadata, handle); + return Compilation.FindModuleByReference(asmRef); + } + + public IModule ResolveModule(ModuleReferenceHandle handle) + { + if (handle.IsNil) + return null; + var modRef = metadata.GetModuleReference(handle); + var name = metadata.GetString(modRef.Name); + foreach (var mod in Compilation.Modules) + { + if (mod.Name == name) + { + return mod; + } + } + return null; + } + + public IModule GetDeclaringModule(TypeReferenceHandle handle) + { + if (handle.IsNil) + return null; + var tr = metadata.GetTypeReference(handle); + switch (tr.ResolutionScope.Kind) + { + case HandleKind.TypeReference: + return GetDeclaringModule((TypeReferenceHandle)tr.ResolutionScope); + case HandleKind.AssemblyReference: + return ResolveModule((AssemblyReferenceHandle)tr.ResolutionScope); + case HandleKind.ModuleReference: + return ResolveModule((ModuleReferenceHandle)tr.ResolutionScope); + default: + return this; + } + } + #endregion + + #region Resolve Type + public IType ResolveType(EntityHandle typeRefDefSpec, GenericContext context, CustomAttributeHandleCollection? typeAttributes = null, Nullability nullableContext = Nullability.Oblivious) + { + if (typeRefDefSpec.IsNil) + return SpecialType.UnknownType; + IType ty; + switch (typeRefDefSpec.Kind) + { + case HandleKind.TypeDefinition: + ty = TypeProvider.GetTypeFromDefinition(metadata, (TypeDefinitionHandle)typeRefDefSpec, 0); + break; + case HandleKind.TypeReference: + ty = TypeProvider.GetTypeFromReference(metadata, (TypeReferenceHandle)typeRefDefSpec, 0); + break; + case HandleKind.TypeSpecification: + var typeSpec = metadata.GetTypeSpecification((TypeSpecificationHandle)typeRefDefSpec); + ty = typeSpec.DecodeSignature(TypeProvider, context); + break; + case HandleKind.ExportedType: + return ResolveForwardedType(metadata.GetExportedType((ExportedTypeHandle)typeRefDefSpec)); + default: + throw new BadImageFormatException("Not a type handle"); + } + ty = ApplyAttributeTypeVisitor.ApplyAttributesToType(ty, Compilation, typeAttributes, metadata, nullableContext); + return ty; + } + + IType ResolveDeclaringType(EntityHandle declaringTypeReference, GenericContext context) + { + // resolve without substituting dynamic/tuple types + var ty = ResolveType(declaringTypeReference, context, null, Nullability.Nullable); + // but substitute tuple types in type arguments: + ty = ApplyAttributeTypeVisitor.ApplyAttributesToType(ty, Compilation, null, metadata, Nullability.Oblivious, typeChildrenOnly: true); + return ty; + } + + IType IntroduceTupleTypes(IType ty) + { + // run ApplyAttributeTypeVisitor without attributes, in order to introduce tuple types + return ApplyAttributeTypeVisitor.ApplyAttributesToType(ty, Compilation, null, metadata, Nullability.Oblivious); + } + #endregion + + #region Resolve Method + public IMethod ResolveMethod(EntityHandle methodReference, GenericContext context) + { + if (methodReference.IsNil) + throw new ArgumentNullException(nameof(methodReference)); + switch (methodReference.Kind) + { + case HandleKind.MethodDefinition: + return ResolveMethodDefinition((MethodDefinitionHandle)methodReference, expandVarArgs: true); + case HandleKind.MemberReference: + return ResolveMethodReference((MemberReferenceHandle)methodReference, context, expandVarArgs: true); + case HandleKind.MethodSpecification: + return ResolveMethodSpecification((MethodSpecificationHandle)methodReference, context, expandVarArgs: true); + default: + throw new BadImageFormatException("Metadata token must be either a methoddef, memberref or methodspec"); + } + } + + IMethod ResolveMethodDefinition(MethodDefinitionHandle methodDefHandle, bool expandVarArgs) + { + var method = GetDefinition(methodDefHandle); + if (expandVarArgs && method.Parameters.LastOrDefault()?.Type.Kind == TypeKind.ArgList) + { + method = new VarArgInstanceMethod(method, EmptyList.Instance); + } + return method; + } + + IMethod ResolveMethodSpecification(MethodSpecificationHandle methodSpecHandle, GenericContext context, bool expandVarArgs) + { + var methodSpec = metadata.GetMethodSpecification(methodSpecHandle); + var methodTypeArgs = methodSpec.DecodeSignature(TypeProvider, context) + .SelectReadOnlyArray(IntroduceTupleTypes); + IMethod method; + if (methodSpec.Method.Kind == HandleKind.MethodDefinition) + { + // generic instance of a methoddef (=generic method in non-generic class in current assembly) + method = ResolveMethodDefinition((MethodDefinitionHandle)methodSpec.Method, expandVarArgs); + method = method.Specialize(new TypeParameterSubstitution(null, methodTypeArgs)); + } + else + { + method = ResolveMethodReference((MemberReferenceHandle)methodSpec.Method, context, methodTypeArgs, expandVarArgs); + } + return method; + } + + /// + /// Resolves a method reference. + /// + /// + /// Class type arguments are provided by the declaring type stored in the memberRef. + /// Method type arguments are provided by the caller. + /// + IMethod ResolveMethodReference(MemberReferenceHandle memberRefHandle, GenericContext context, IReadOnlyList methodTypeArguments = null, bool expandVarArgs = true) + { + var memberRef = metadata.GetMemberReference(memberRefHandle); + Debug.Assert(memberRef.GetKind() == MemberReferenceKind.Method); + MethodSignature signature; + IReadOnlyList classTypeArguments = null; + IMethod method; + if (memberRef.Parent.Kind == HandleKind.MethodDefinition) + { + method = ResolveMethodDefinition((MethodDefinitionHandle)memberRef.Parent, expandVarArgs: false); + signature = memberRef.DecodeMethodSignature(TypeProvider, context); + } + else + { + var declaringType = ResolveDeclaringType(memberRef.Parent, context); + var declaringTypeDefinition = declaringType.GetDefinition(); + if (declaringType.TypeArguments.Count > 0) + { + classTypeArguments = declaringType.TypeArguments; + } + // Note: declaringType might be parameterized, but the signature is for the original method definition. + // We'll have to search the member directly on declaringTypeDefinition. + var name = metadata.GetString(memberRef.Name); + signature = memberRef.DecodeMethodSignature(TypeProvider, + new GenericContext(declaringTypeDefinition?.TypeParameters)); + if (declaringTypeDefinition != null) + { + // Find the set of overloads to search: + IEnumerable methods; + if (name == ".ctor") + { + methods = declaringTypeDefinition.GetConstructors(); + } + else if (name == ".cctor") + { + methods = declaringTypeDefinition.Methods.Where(m => m.IsConstructor && m.IsStatic); + } + else + { + methods = declaringTypeDefinition.GetMethods(m => m.Name == name, GetMemberOptions.IgnoreInheritedMembers) + .Concat(declaringTypeDefinition.GetAccessors(m => m.Name == name, GetMemberOptions.IgnoreInheritedMembers)); + } + // Determine the expected parameters from the signature: + ImmutableArray parameterTypes; + if (signature.Header.CallingConvention == SignatureCallingConvention.VarArgs) + { + parameterTypes = signature.ParameterTypes + .Take(signature.RequiredParameterCount) + .Concat(new[] { SpecialType.ArgList }) + .ToImmutableArray(); + } + else + { + parameterTypes = signature.ParameterTypes; + } + // Search for the matching method: + method = null; + foreach (var m in methods) + { + if (m.TypeParameters.Count != signature.GenericParameterCount) + continue; + if (CompareSignatures(m.Parameters, parameterTypes) && CompareTypes(m.ReturnType, signature.ReturnType)) + { + method = m; + break; + } + } + } + else + { + method = null; + } + if (method == null) + { + method = CreateFakeMethod(declaringType, name, signature); + } + } + if (classTypeArguments != null || methodTypeArguments != null) + { + method = method.Specialize(new TypeParameterSubstitution(classTypeArguments, methodTypeArguments)); + } + if (expandVarArgs && signature.Header.CallingConvention == SignatureCallingConvention.VarArgs) + { + method = new VarArgInstanceMethod(method, signature.ParameterTypes.Skip(signature.RequiredParameterCount)); + } + return method; + } + + static readonly NormalizeTypeVisitor normalizeTypeVisitor = new NormalizeTypeVisitor + { + ReplaceClassTypeParametersWithDummy = true, + ReplaceMethodTypeParametersWithDummy = true, + }; + + static bool CompareTypes(IType a, IType b) + { + var type1 = a.AcceptVisitor(normalizeTypeVisitor); + var type2 = b.AcceptVisitor(normalizeTypeVisitor); + return type1.Equals(type2); + } + + static bool CompareSignatures(IReadOnlyList parameters, ImmutableArray parameterTypes) + { + if (parameterTypes.Length != parameters.Count) + return false; + for (var i = 0; i < parameterTypes.Length; i++) + { + if (!CompareTypes(parameterTypes[i], parameters[i].Type)) + return false; + } + return true; + } + + /// + /// Create a dummy IMethod from the specified MethodReference + /// + IMethod CreateFakeMethod(IType declaringType, string name, MethodSignature signature) + { + var symbolKind = SymbolKind.Method; + if (name == ".ctor" || name == ".cctor") + symbolKind = SymbolKind.Constructor; + var m = new FakeMethod(Compilation, symbolKind); + m.DeclaringType = declaringType; + m.Name = name; + m.ReturnType = signature.ReturnType; + m.IsStatic = !signature.Header.IsInstance; + + TypeParameterSubstitution substitution = null; + if (signature.GenericParameterCount > 0) + { + var typeParameters = new List(); + for (var i = 0; i < signature.GenericParameterCount; i++) + { + typeParameters.Add(new DefaultTypeParameter(m, i)); + } + m.TypeParameters = typeParameters; + substitution = new TypeParameterSubstitution(declaringType.TypeArguments, typeParameters); + } + else if (declaringType.TypeArguments.Count > 0) + { + substitution = declaringType.GetSubstitution(); + } + var parameters = new List(); + for (var i = 0; i < signature.RequiredParameterCount; i++) + { + var type = signature.ParameterTypes[i]; + if (substitution != null) + { + // replace the dummy method type parameters with the owned instances we just created + type = type.AcceptVisitor(substitution); + } + parameters.Add(new DefaultParameter(type, "")); + } + m.Parameters = parameters; + return m; + } + #endregion + + #region Resolve Entity + /// + /// Resolves a symbol. + /// + /// + /// * Types are resolved to their definition, as IType does not implement ISymbol. + /// * types without definition will resolve to null + /// * use ResolveType() to properly resolve types + /// * When resolving methods, varargs signatures are not expanded. + /// * use ResolveMethod() instead to get an IMethod instance suitable for call-sites + /// * May return specialized members, where generics are involved. + /// * Other types of handles that don't correspond to TS entities, will return null. + /// + public IEntity ResolveEntity(EntityHandle entityHandle, GenericContext context = default) + { + switch (entityHandle.Kind) + { + case HandleKind.TypeReference: + case HandleKind.TypeDefinition: + case HandleKind.TypeSpecification: + case HandleKind.ExportedType: + return ResolveType(entityHandle, context).GetDefinition(); + case HandleKind.MemberReference: + var memberReferenceHandle = (MemberReferenceHandle)entityHandle; + switch (metadata.GetMemberReference(memberReferenceHandle).GetKind()) + { + case MemberReferenceKind.Method: + // for consistency with the MethodDefinition case, never expand varargs + return ResolveMethodReference(memberReferenceHandle, context, expandVarArgs: false); + case MemberReferenceKind.Field: + return ResolveFieldReference(memberReferenceHandle, context); + default: + throw new BadImageFormatException("Unknown MemberReferenceKind"); + } + case HandleKind.MethodDefinition: + return GetDefinition((MethodDefinitionHandle)entityHandle); + case HandleKind.MethodSpecification: + return ResolveMethodSpecification((MethodSpecificationHandle)entityHandle, context, expandVarArgs: false); + case HandleKind.FieldDefinition: + return GetDefinition((FieldDefinitionHandle)entityHandle); + case HandleKind.EventDefinition: + return GetDefinition((EventDefinitionHandle)entityHandle); + case HandleKind.PropertyDefinition: + return GetDefinition((PropertyDefinitionHandle)entityHandle); + default: + return null; + } + } + + IField ResolveFieldReference(MemberReferenceHandle memberReferenceHandle, GenericContext context) + { + var memberRef = metadata.GetMemberReference(memberReferenceHandle); + var declaringType = ResolveDeclaringType(memberRef.Parent, context); + var declaringTypeDefinition = declaringType.GetDefinition(); + var name = metadata.GetString(memberRef.Name); + // field signature is for the definition, not the generic instance + var signature = memberRef.DecodeFieldSignature(TypeProvider, + new GenericContext(declaringTypeDefinition?.TypeParameters)); + // 'f' in the predicate is also the definition, even if declaringType is a ParameterizedType + var field = declaringType.GetFields(f => f.Name == name && CompareTypes(f.ReturnType, signature), + GetMemberOptions.IgnoreInheritedMembers).FirstOrDefault(); + if (field == null) + { + // If it's a field in a generic type, we need to substitute the type arguments: + if (declaringType.TypeArguments.Count > 0) + { + signature = signature.AcceptVisitor(declaringType.GetSubstitution()); + } + field = new FakeField(Compilation) + { + ReturnType = signature, + Name = name, + DeclaringType = declaringType, + }; + } + return field; + } + #endregion + + #region Decode Standalone Signature + public (SignatureHeader, FunctionPointerType) DecodeMethodSignature(StandaloneSignatureHandle handle, GenericContext genericContext) + { + var standaloneSignature = metadata.GetStandaloneSignature(handle); + if (standaloneSignature.GetKind() != StandaloneSignatureKind.Method) + throw new BadImageFormatException("Expected Method signature"); + var sig = standaloneSignature.DecodeMethodSignature(TypeProvider, genericContext); + var fpt = FunctionPointerType.FromSignature(sig, this); + return (sig.Header, (FunctionPointerType)IntroduceTupleTypes(fpt)); + } + + public ImmutableArray DecodeLocalSignature(StandaloneSignatureHandle handle, GenericContext genericContext) + { + var standaloneSignature = metadata.GetStandaloneSignature(handle); + if (standaloneSignature.GetKind() != StandaloneSignatureKind.LocalVariables) + throw new BadImageFormatException("Expected LocalVariables signature"); + var types = standaloneSignature.DecodeLocalSignature(TypeProvider, genericContext); + return ImmutableArray.CreateRange(types, IntroduceTupleTypes); + } + #endregion + + #region Module / Assembly attributes + /// + /// Gets the list of all assembly attributes in the project. + /// + public IEnumerable GetAssemblyAttributes() + { + var b = new AttributeListBuilder(this); + if (metadata.IsAssembly) + { + var assembly = metadata.GetAssemblyDefinition(); + b.Add(metadata.GetCustomAttributes(Handle.AssemblyDefinition), SymbolKind.Module); + b.AddSecurityAttributes(assembly.GetDeclarativeSecurityAttributes()); + + // AssemblyVersionAttribute + if (assembly.Version != null) + { + b.Add(KnownAttribute.AssemblyVersion, KnownTypeCode.String, assembly.Version.ToString()); + } + + AddTypeForwarderAttributes(ref b); + } + return b.Build(); + } + + /// + /// Gets the list of all module attributes in the project. + /// + public IEnumerable GetModuleAttributes() + { + var b = new AttributeListBuilder(this); + b.Add(metadata.GetCustomAttributes(Handle.ModuleDefinition), SymbolKind.Module); + if (!metadata.IsAssembly) + { + AddTypeForwarderAttributes(ref b); + } + return b.Build(); + } + + void AddTypeForwarderAttributes(ref AttributeListBuilder b) + { + foreach (var t in metadata.ExportedTypes) + { + var type = metadata.GetExportedType(t); + if (type.IsForwarder) + { + b.Add(KnownAttribute.TypeForwardedTo, KnownTypeCode.Type, ResolveForwardedType(type)); + } + } + } + + IType ResolveForwardedType(ExportedType forwarder) + { + var module = ResolveModule(forwarder); + var typeName = forwarder.GetFullTypeName(metadata); + if (module == null) + return new UnknownType(typeName); + using (var busyLock = BusyManager.Enter(this)) + { + if (busyLock.Success) + { + var td = module.GetTypeDefinition(typeName); + if (td != null) + { + return td; + } + } + } + return new UnknownType(typeName); + + IModule ResolveModule(ExportedType type) + { + switch (type.Implementation.Kind) + { + case HandleKind.AssemblyFile: + // TODO : Resolve assembly file (module)... + return this; + case HandleKind.ExportedType: + var outerType = metadata.GetExportedType((ExportedTypeHandle)type.Implementation); + return ResolveModule(outerType); + case HandleKind.AssemblyReference: + var asmRef = metadata.GetAssemblyReference((AssemblyReferenceHandle)type.Implementation); + var shortName = metadata.GetString(asmRef.Name); + foreach (var asm in Compilation.Modules) + { + if (string.Equals(asm.AssemblyName, shortName, StringComparison.OrdinalIgnoreCase)) + { + return asm; + } + } + return null; + default: + throw new BadImageFormatException("Expected implementation to be either an AssemblyFile, ExportedType or AssemblyReference."); + } + } + } + #endregion + + #region Attribute Helpers + /// + /// Cache for parameterless known attribute types. + /// + readonly IType[] knownAttributeTypes = new IType[KnownAttributes.Count]; + + internal IType GetAttributeType(KnownAttribute attr) + { + var ty = LazyInit.VolatileRead(ref knownAttributeTypes[(int)attr]); + if (ty != null) + return ty; + ty = Compilation.FindType(attr.GetTypeName()); + return LazyInit.GetOrSet(ref knownAttributeTypes[(int)attr], ty); + } + + /// + /// Cache for parameterless known attributes. + /// + readonly IAttribute[] knownAttributes = new IAttribute[KnownAttributes.Count]; + + /// + /// Construct a builtin attribute. + /// + internal IAttribute MakeAttribute(KnownAttribute type) + { + var attr = LazyInit.VolatileRead(ref knownAttributes[(int)type]); + if (attr != null) + return attr; + attr = new DefaultAttribute(GetAttributeType(type), + ImmutableArray.Create>(), + ImmutableArray.Create>()); + return LazyInit.GetOrSet(ref knownAttributes[(int)type], attr); + } + #endregion + + #region Visibility Filter + internal bool IncludeInternalMembers => true; + + internal bool IsVisible(FieldAttributes att) + { + att &= FieldAttributes.FieldAccessMask; + return IncludeInternalMembers + || att == FieldAttributes.Public + || att == FieldAttributes.Family + || att == FieldAttributes.FamORAssem; + } + + internal bool IsVisible(MethodAttributes att) + { + att &= MethodAttributes.MemberAccessMask; + return IncludeInternalMembers + || att == MethodAttributes.Public + || att == MethodAttributes.Family + || att == MethodAttributes.FamORAssem; + } + #endregion + + #region Nullability Reference Type Support + readonly Accessibility minAccessibilityForNRT; + + static Accessibility FindMinimumAccessibilityForNRT(MetadataReader metadata, CustomAttributeHandleCollection customAttributes) + { + // Determine the minimum effective accessibility an entity must have, so that the metadata stores the nullability for its type. + foreach (var handle in customAttributes) + { + var customAttribute = metadata.GetCustomAttribute(handle); + if (customAttribute.IsKnownAttribute(metadata, KnownAttribute.NullablePublicOnly)) + { + CustomAttributeValue value; + try + { + value = customAttribute.DecodeValue(Metadata.MetadataExtensions.MinimalAttributeTypeProvider); + } + catch (BadImageFormatException) + { + continue; + } + catch (EnumUnderlyingTypeResolveException) + { + continue; + } + if (value.FixedArguments.Length == 1 && value.FixedArguments[0].Value is bool includesInternals) + { + return includesInternals ? Accessibility.ProtectedAndInternal : Accessibility.Protected; + } + } + } + return Accessibility.None; + } + + internal bool ShouldDecodeNullableAttributes(IEntity entity) + { + return true; + } + + #endregion + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ModifiedType.cs b/src/ICSharpCode.Decompiler/TypeSystem/ModifiedType.cs new file mode 100644 index 0000000..2fcff32 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ModifiedType.cs @@ -0,0 +1,143 @@ +// Copyright (c) 2018 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.TypeSystem.Implementation +{ + /// + /// Represents a modopt or modreq type. + /// + public class ModifiedType : TypeWithElementType, IType + { + readonly TypeKind kind; + readonly IType modifier; + + public ModifiedType(IType modifier, IType unmodifiedType, bool isRequired) : base(unmodifiedType) + { + this.kind = isRequired ? TypeKind.ModReq : TypeKind.ModOpt; + this.modifier = modifier ?? throw new ArgumentNullException(nameof(modifier)); + } + + public IType Modifier => modifier; + public override TypeKind Kind => kind; + + public override string NameSuffix => (kind == TypeKind.ModReq ? " modreq" : " modopt") + $"({modifier.FullName})"; + + public override bool? IsReferenceType => elementType.IsReferenceType; + public override bool IsByRefLike => elementType.IsByRefLike; + public override Nullability Nullability => elementType.Nullability; + + public override IType ChangeNullability(Nullability nullability) + { + var newElementType = elementType.ChangeNullability(nullability); + if (newElementType == elementType) + return this; + else + return new ModifiedType(modifier, newElementType, kind == TypeKind.ModReq); + } + + public override ITypeDefinition GetDefinition() + { + return elementType.GetDefinition(); + } + + public override IEnumerable GetAccessors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return elementType.GetAccessors(filter, options); + } + + public override IEnumerable GetConstructors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.IgnoreInheritedMembers) + { + return elementType.GetConstructors(filter, options); + } + + public override IEnumerable GetEvents(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return elementType.GetEvents(filter, options); + } + + public override IEnumerable GetFields(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return elementType.GetFields(filter, options); + } + + public override IEnumerable GetMembers(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return elementType.GetMembers(filter, options); + } + + public override IEnumerable GetMethods(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return elementType.GetMethods(typeArguments, filter, options); + } + + public override IEnumerable GetMethods(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return elementType.GetMethods(filter, options); + } + + public override IEnumerable GetNestedTypes(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return elementType.GetNestedTypes(typeArguments, filter, options); + } + + public override IEnumerable GetNestedTypes(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return elementType.GetNestedTypes(filter, options); + } + + public override IEnumerable GetProperties(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return elementType.GetProperties(filter, options); + } + + public override IType VisitChildren(TypeVisitor visitor) + { + var newElementType = elementType.AcceptVisitor(visitor); + var newModifier = modifier.AcceptVisitor(visitor); + if (newModifier != modifier || newElementType != elementType) + { + return new ModifiedType(newModifier, newElementType, kind == TypeKind.ModReq); + } + return this; + } + + public override IType AcceptVisitor(TypeVisitor visitor) + { + if (kind == TypeKind.ModReq) + return visitor.VisitModReq(this); + else + return visitor.VisitModOpt(this); + } + + public override bool Equals(IType other) + { + return other is ModifiedType o && kind == o.kind && modifier.Equals(o.modifier) && elementType.Equals(o.elementType); + } + + public override int GetHashCode() + { + unchecked + { + return (int)kind ^ (elementType.GetHashCode() * 1344795899) ^ (modifier.GetHashCode() * 901375117); + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/NormalizeTypeVisitor.cs b/src/ICSharpCode.Decompiler/TypeSystem/NormalizeTypeVisitor.cs new file mode 100644 index 0000000..4cd017d --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/NormalizeTypeVisitor.cs @@ -0,0 +1,140 @@ +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + sealed class NormalizeTypeVisitor : TypeVisitor + { + /// + /// NormalizeTypeVisitor that does not normalize type parameters, + /// but performs type erasure (object->dynamic; tuple->underlying type). + /// + internal static readonly NormalizeTypeVisitor TypeErasure = new NormalizeTypeVisitor { + ReplaceClassTypeParametersWithDummy = false, + ReplaceMethodTypeParametersWithDummy = false, + DynamicAndObject = true, + IntPtrToNInt = true, + TupleToUnderlyingType = true, + RemoveModOpt = true, + RemoveModReq = true, + RemoveNullability = true, + }; + + internal static readonly NormalizeTypeVisitor IgnoreNullabilityAndTuples = new NormalizeTypeVisitor { + ReplaceClassTypeParametersWithDummy = false, + ReplaceMethodTypeParametersWithDummy = false, + DynamicAndObject = false, + IntPtrToNInt = false, + TupleToUnderlyingType = true, + RemoveModOpt = true, + RemoveModReq = true, + RemoveNullability = true, + }; + + public bool EquivalentTypes(IType a, IType b) + { + a = a.AcceptVisitor(this); + b = b.AcceptVisitor(this); + return a.Equals(b); + } + + public bool RemoveModOpt = true; + public bool RemoveModReq = true; + public bool ReplaceClassTypeParametersWithDummy = true; + public bool ReplaceMethodTypeParametersWithDummy = true; + public bool DynamicAndObject = true; + public bool IntPtrToNInt = true; + public bool TupleToUnderlyingType = true; + public bool RemoveNullability = true; + + public override IType VisitTypeParameter(ITypeParameter type) + { + if (type.OwnerType == SymbolKind.Method && ReplaceMethodTypeParametersWithDummy) + { + return DummyTypeParameter.GetMethodTypeParameter(type.Index); + } + else if (type.OwnerType == SymbolKind.TypeDefinition && ReplaceClassTypeParametersWithDummy) + { + return DummyTypeParameter.GetClassTypeParameter(type.Index); + } + else if (RemoveNullability && type is NullabilityAnnotatedTypeParameter natp) + { + return natp.TypeWithoutAnnotation.AcceptVisitor(this); + } + else + { + return base.VisitTypeParameter(type); + } + } + + public override IType VisitTypeDefinition(ITypeDefinition type) + { + switch (type.KnownTypeCode) + { + case KnownTypeCode.Object when DynamicAndObject: + // Instead of normalizing dynamic->object, + // we do this the opposite direction, so that we don't need a compilation to find the object type. + if (RemoveNullability) + return SpecialType.Dynamic; + else + return SpecialType.Dynamic.ChangeNullability(type.Nullability); + case KnownTypeCode.IntPtr when IntPtrToNInt: + return SpecialType.NInt; + case KnownTypeCode.UIntPtr when IntPtrToNInt: + return SpecialType.NUInt; + } + return base.VisitTypeDefinition(type); + } + + public override IType VisitTupleType(TupleType type) + { + if (TupleToUnderlyingType) + { + return type.UnderlyingType.AcceptVisitor(this); + } + else + { + return base.VisitTupleType(type); + } + } + + public override IType VisitNullabilityAnnotatedType(NullabilityAnnotatedType type) + { + if (RemoveNullability) + return type.TypeWithoutAnnotation.AcceptVisitor(this); + else + return base.VisitNullabilityAnnotatedType(type); + } + + public override IType VisitArrayType(ArrayType type) + { + if (RemoveNullability) + return base.VisitArrayType(type).ChangeNullability(Nullability.Oblivious); + else + return base.VisitArrayType(type); + } + + public override IType VisitModOpt(ModifiedType type) + { + if (RemoveModOpt) + { + return type.ElementType.AcceptVisitor(this); + } + else + { + return base.VisitModOpt(type); + } + } + + public override IType VisitModReq(ModifiedType type) + { + if (RemoveModReq) + { + return type.ElementType.AcceptVisitor(this); + } + else + { + return base.VisitModReq(type); + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/Nullability.cs b/src/ICSharpCode.Decompiler/TypeSystem/Nullability.cs new file mode 100644 index 0000000..8e87c75 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/Nullability.cs @@ -0,0 +1,9 @@ +namespace ICSharpCode.Decompiler.TypeSystem +{ + public enum Nullability : byte + { + Oblivious = 0, + NotNullable = 1, + Nullable = 2 + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/NullableType.cs b/src/ICSharpCode.Decompiler/TypeSystem/NullableType.cs new file mode 100644 index 0000000..a04c9af --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/NullableType.cs @@ -0,0 +1,87 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Static helper methods for working with nullable types. + /// + public static class NullableType + { + /// + /// Gets whether the specified type is a nullable type. + /// + public static bool IsNullable(IType type) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + var pt = type.SkipModifiers() as ParameterizedType; + return pt != null && pt.TypeParameterCount == 1 && pt.GenericType.IsKnownType(KnownTypeCode.NullableOfT); + } + + public static bool IsNonNullableValueType(IType type) + { + return type.IsReferenceType == false && !IsNullable(type); + } + + /// + /// Returns the element type, if is a nullable type. + /// Otherwise, returns the type itself. + /// + public static IType GetUnderlyingType(IType type) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + var pt = type.SkipModifiers() as ParameterizedType; + if (pt != null && pt.TypeParameterCount == 1 && pt.GenericType.IsKnownType(KnownTypeCode.NullableOfT)) + return pt.GetTypeArgument(0); + else + return type; + } + + /// + /// Creates a nullable type. + /// + public static IType Create(ICompilation compilation, IType elementType) + { + if (compilation == null) + throw new ArgumentNullException(nameof(compilation)); + if (elementType == null) + throw new ArgumentNullException(nameof(elementType)); + + var nullableType = compilation.FindType(KnownTypeCode.NullableOfT); + var nullableTypeDef = nullableType.GetDefinition(); + if (nullableTypeDef != null) + return new ParameterizedType(nullableTypeDef, new[] { elementType }); + else + return nullableType; + } + + /// + /// Creates a nullable type reference. + /// + public static ParameterizedTypeReference Create(ITypeReference elementType) + { + if (elementType == null) + throw new ArgumentNullException(nameof(elementType)); + return new ParameterizedTypeReference(KnownTypeReference.Get(KnownTypeCode.NullableOfT), new[] { elementType }); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ParameterListComparer.cs b/src/ICSharpCode.Decompiler/TypeSystem/ParameterListComparer.cs new file mode 100644 index 0000000..a980841 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ParameterListComparer.cs @@ -0,0 +1,166 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Compares parameter lists by comparing the types of all parameters. + /// + /// + /// 'ref int' and 'out int' are considered to be equal - unless is set to true. + /// 'object' and 'dynamic' are also equal. + /// For generic methods, "Method{T}(T a)" and "Method{S}(S b)" are considered equal. + /// However, "Method(T a)" and "Method(S b)" are not considered equal when the type parameters T and S belong to classes. + /// + public sealed class ParameterListComparer : IEqualityComparer> + { + public static readonly ParameterListComparer Instance = new ParameterListComparer(); + + static readonly NormalizeTypeVisitor normalizationVisitor = new NormalizeTypeVisitor { + ReplaceClassTypeParametersWithDummy = false, + ReplaceMethodTypeParametersWithDummy = true, + DynamicAndObject = true, + TupleToUnderlyingType = true, + }; + + bool includeModifiers; + + public static ParameterListComparer WithOptions(bool includeModifiers = false) + { + return new ParameterListComparer() { + includeModifiers = includeModifiers + }; + } + + public bool Equals(IReadOnlyList x, IReadOnlyList y) + { + if (x == y) + return true; + if (x == null || y == null || x.Count != y.Count) + return false; + for (var i = 0; i < x.Count; i++) + { + var a = x[i]; + var b = y[i]; + if (a == null && b == null) + continue; + if (a == null || b == null) + return false; + + if (includeModifiers) + { + if (a.ReferenceKind != b.ReferenceKind) + return false; + if (a.IsParams != b.IsParams) + return false; + } + + // We want to consider the parameter lists "Method(T a)" and "Method(S b)" as equal. + // However, the parameter types are not considered equal, as T is a different type parameter than S. + // In order to compare the method signatures, we will normalize all method type parameters. + var aType = a.Type.AcceptVisitor(normalizationVisitor); + var bType = b.Type.AcceptVisitor(normalizationVisitor); + + if (!aType.Equals(bType)) + return false; + } + return true; + } + + public int GetHashCode(IReadOnlyList obj) + { + var hashCode = obj.Count; + unchecked + { + foreach (var p in obj) + { + hashCode *= 27; + var type = p.Type.AcceptVisitor(normalizationVisitor); + hashCode += type.GetHashCode(); + } + } + return hashCode; + } + } + + /// + /// Compares member signatures. + /// + /// + /// This comparer checks for equal short name, equal type parameter count, and equal parameter types (using ParameterListComparer). + /// + public sealed class SignatureComparer : IEqualityComparer + { + StringComparer nameComparer; + + public SignatureComparer(StringComparer nameComparer) + { + if (nameComparer == null) + throw new ArgumentNullException(nameof(nameComparer)); + this.nameComparer = nameComparer; + } + + /// + /// Gets a signature comparer that uses an ordinal comparison for the member name. + /// + public static readonly SignatureComparer Ordinal = new SignatureComparer(StringComparer.Ordinal); + + public bool Equals(IMember x, IMember y) + { + if (x == y) + return true; + if (x == null || y == null || x.SymbolKind != y.SymbolKind || !nameComparer.Equals(x.Name, y.Name)) + return false; + var px = x as IParameterizedMember; + var py = y as IParameterizedMember; + if (px != null && py != null) + { + var mx = x as IMethod; + var my = y as IMethod; + if (mx != null && my != null && mx.TypeParameters.Count != my.TypeParameters.Count) + return false; + return ParameterListComparer.Instance.Equals(px.Parameters, py.Parameters); + } + else + { + return true; + } + } + + public int GetHashCode(IMember obj) + { + unchecked + { + var hash = (int)obj.SymbolKind * 33 + nameComparer.GetHashCode(obj.Name); + var pm = obj as IParameterizedMember; + if (pm != null) + { + hash *= 27; + hash += ParameterListComparer.Instance.GetHashCode(pm.Parameters); + var m = pm as IMethod; + if (m != null) + hash += m.TypeParameters.Count; + } + return hash; + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ParameterizedType.cs b/src/ICSharpCode.Decompiler/TypeSystem/ParameterizedType.cs new file mode 100644 index 0000000..e648360 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ParameterizedType.cs @@ -0,0 +1,454 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Text; + +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// ParameterizedType represents an instance of a generic type. + /// Example: List<string> + /// + /// + /// When getting the members, this type modifies the lists so that + /// type parameters in the signatures of the members are replaced with + /// the type arguments. + /// + [Serializable] + public sealed class ParameterizedType : IType + { + readonly IType genericType; + readonly IType[] typeArguments; + + public ParameterizedType(IType genericType, IEnumerable typeArguments) + { + if (genericType == null) + throw new ArgumentNullException(nameof(genericType)); + if (typeArguments == null) + throw new ArgumentNullException(nameof(typeArguments)); + this.genericType = genericType; + this.typeArguments = typeArguments.ToArray(); // copy input array to ensure it isn't modified + if (this.typeArguments.Length == 0) + throw new ArgumentException("Cannot use ParameterizedType with 0 type arguments."); + if (genericType.TypeParameterCount != this.typeArguments.Length) + throw new ArgumentException("Number of type arguments must match the type definition's number of type parameters"); + var gp = genericType as ICompilationProvider; + for (var i = 0; i < this.typeArguments.Length; i++) + { + if (this.typeArguments[i] == null) + throw new ArgumentNullException("typeArguments[" + i + "]"); + var p = this.typeArguments[i] as ICompilationProvider; + if (p != null && gp != null && p.Compilation != gp.Compilation) + throw new InvalidOperationException("Cannot parameterize a type with type arguments from a different compilation."); + } + } + + /// + /// Fast internal version of the constructor. (no safety checks) + /// Keeps the array that was passed and assumes it won't be modified. + /// + internal ParameterizedType(IType genericType, params IType[] typeArguments) + { + Debug.Assert(genericType.TypeParameterCount == typeArguments.Length); + this.genericType = genericType; + this.typeArguments = typeArguments; + } + + public TypeKind Kind { + get { return genericType.Kind; } + } + + public IType GenericType { + get { return genericType; } + } + + public bool? IsReferenceType => genericType.IsReferenceType; + public bool IsByRefLike => genericType.IsByRefLike; + public Nullability Nullability => genericType.Nullability; + + public IType ChangeNullability(Nullability nullability) + { + var newGenericType = genericType.ChangeNullability(nullability); + if (newGenericType == genericType) + return this; + else + return new ParameterizedType(newGenericType, typeArguments); + } + + public IType DeclaringType { + get { + var declaringType = genericType.DeclaringType; + if (declaringType != null && declaringType.TypeParameterCount > 0 + && declaringType.TypeParameterCount <= genericType.TypeParameterCount) + { + var newTypeArgs = new IType[declaringType.TypeParameterCount]; + Array.Copy(this.typeArguments, 0, newTypeArgs, 0, newTypeArgs.Length); + return new ParameterizedType(declaringType, newTypeArgs); + } + return declaringType; + } + } + + public int TypeParameterCount { + get { return typeArguments.Length; } + } + + public string FullName { + get { return genericType.FullName; } + } + + public string Name { + get { return genericType.Name; } + } + + public string Namespace { + get { return genericType.Namespace; } + } + + public string ReflectionName { + get { + var b = new StringBuilder(genericType.ReflectionName); + b.Append('['); + for (var i = 0; i < typeArguments.Length; i++) + { + if (i > 0) + b.Append(','); + b.Append('['); + b.Append(typeArguments[i].ReflectionName); + b.Append(']'); + } + b.Append(']'); + return b.ToString(); + } + } + + public override string ToString() + { + var b = new StringBuilder(genericType.ToString()); + b.Append('['); + for (var i = 0; i < typeArguments.Length; i++) + { + if (i > 0) + b.Append(','); + b.Append('['); + b.Append(typeArguments[i].ToString()); + b.Append(']'); + } + b.Append(']'); + return b.ToString(); + } + + public IReadOnlyList TypeArguments => typeArguments; + + /// + /// Same as 'parameterizedType.TypeArguments[index]'. + /// + public IType GetTypeArgument(int index) + { + return typeArguments[index]; + } + + public IReadOnlyList TypeParameters => genericType.TypeParameters; + + /// + /// Gets the definition of the generic type. + /// For ParameterizedType, this method never returns null. + /// + public ITypeDefinition GetDefinition() + { + return genericType.GetDefinition(); + } + + /// + /// Gets a type visitor that performs the substitution of class type parameters with the type arguments + /// of this parameterized type. + /// + public TypeParameterSubstitution GetSubstitution() + { + return new TypeParameterSubstitution(typeArguments, null); + } + + /// + /// Gets a type visitor that performs the substitution of class type parameters with the type arguments + /// of this parameterized type, + /// and also substitutes method type parameters with the specified method type arguments. + /// + public TypeParameterSubstitution GetSubstitution(IReadOnlyList methodTypeArguments) + { + return new TypeParameterSubstitution(typeArguments, methodTypeArguments); + } + + public IEnumerable DirectBaseTypes { + get { + var substitution = GetSubstitution(); + return genericType.DirectBaseTypes.Select(t => t.AcceptVisitor(substitution)); + } + } + + public IEnumerable GetNestedTypes(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) + return genericType.GetNestedTypes(filter, options); + else + return GetMembersHelper.GetNestedTypes(this, filter, options); + } + + public IEnumerable GetNestedTypes(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) + return genericType.GetNestedTypes(typeArguments, filter, options); + else + return GetMembersHelper.GetNestedTypes(this, typeArguments, filter, options); + } + + public IEnumerable GetConstructors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.IgnoreInheritedMembers) + { + if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) + return genericType.GetConstructors(filter, options); + else + return GetMembersHelper.GetConstructors(this, filter, options); + } + + public IEnumerable GetMethods(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) + return genericType.GetMethods(filter, options); + else + return GetMembersHelper.GetMethods(this, filter, options); + } + + public IEnumerable GetMethods(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) + return genericType.GetMethods(typeArguments, filter, options); + else + return GetMembersHelper.GetMethods(this, typeArguments, filter, options); + } + + public IEnumerable GetProperties(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) + return genericType.GetProperties(filter, options); + else + return GetMembersHelper.GetProperties(this, filter, options); + } + + public IEnumerable GetFields(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) + return genericType.GetFields(filter, options); + else + return GetMembersHelper.GetFields(this, filter, options); + } + + public IEnumerable GetEvents(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) + return genericType.GetEvents(filter, options); + else + return GetMembersHelper.GetEvents(this, filter, options); + } + + public IEnumerable GetMembers(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) + return genericType.GetMembers(filter, options); + else + return GetMembersHelper.GetMembers(this, filter, options); + } + + public IEnumerable GetAccessors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + if ((options & GetMemberOptions.ReturnMemberDefinitions) == GetMemberOptions.ReturnMemberDefinitions) + return genericType.GetAccessors(filter, options); + else + return GetMembersHelper.GetAccessors(this, filter, options); + } + + public override bool Equals(object obj) + { + return Equals(obj as IType); + } + + public bool Equals(IType other) + { + if (this == other) + return true; + var c = other as ParameterizedType; + if (c == null || !genericType.Equals(c.genericType) || typeArguments.Length != c.typeArguments.Length) + return false; + for (var i = 0; i < typeArguments.Length; i++) + { + if (!typeArguments[i].Equals(c.typeArguments[i])) + return false; + } + return true; + } + + public override int GetHashCode() + { + var hashCode = genericType.GetHashCode(); + unchecked + { + foreach (var ta in typeArguments) + { + hashCode *= 1000000007; + hashCode += 1000000009 * ta.GetHashCode(); + } + } + return hashCode; + } + + public IType AcceptVisitor(TypeVisitor visitor) + { + return visitor.VisitParameterizedType(this); + } + + public IType VisitChildren(TypeVisitor visitor) + { + var g = genericType.AcceptVisitor(visitor); + // Keep ta == null as long as no elements changed, allocate the array only if necessary. + var ta = (g != genericType) ? new IType[typeArguments.Length] : null; + for (var i = 0; i < typeArguments.Length; i++) + { + var r = typeArguments[i].AcceptVisitor(visitor); + if (r == null) + throw new NullReferenceException("TypeVisitor.Visit-method returned null"); + if (ta == null && r != typeArguments[i]) + { + // we found a difference, so we need to allocate the array + ta = new IType[typeArguments.Length]; + for (var j = 0; j < i; j++) + { + ta[j] = typeArguments[j]; + } + } + if (ta != null) + ta[i] = r; + } + if (ta == null) + return this; + else + return new ParameterizedType(g, ta ?? typeArguments); + } + } + + /// + /// ParameterizedTypeReference is a reference to generic class that specifies the type parameters. + /// Example: List<string> + /// + [Serializable] + public sealed class ParameterizedTypeReference : ITypeReference, ISupportsInterning + { + readonly ITypeReference genericType; + readonly ITypeReference[] typeArguments; + + public ParameterizedTypeReference(ITypeReference genericType, IEnumerable typeArguments) + { + if (genericType == null) + throw new ArgumentNullException(nameof(genericType)); + if (typeArguments == null) + throw new ArgumentNullException(nameof(typeArguments)); + this.genericType = genericType; + this.typeArguments = typeArguments.ToArray(); + for (var i = 0; i < this.typeArguments.Length; i++) + { + if (this.typeArguments[i] == null) + throw new ArgumentNullException("typeArguments[" + i + "]"); + } + } + + public ITypeReference GenericType { + get { return genericType; } + } + + public IReadOnlyList TypeArguments { + get { + return typeArguments; + } + } + + public IType Resolve(ITypeResolveContext context) + { + var baseType = genericType.Resolve(context); + var tpc = baseType.TypeParameterCount; + if (tpc == 0) + return baseType; + var resolvedTypes = new IType[tpc]; + for (var i = 0; i < resolvedTypes.Length; i++) + { + if (i < typeArguments.Length) + resolvedTypes[i] = typeArguments[i].Resolve(context); + else + resolvedTypes[i] = SpecialType.UnknownType; + } + return new ParameterizedType(baseType, resolvedTypes); + } + + public override string ToString() + { + var b = new StringBuilder(genericType.ToString()); + b.Append('['); + for (var i = 0; i < typeArguments.Length; i++) + { + if (i > 0) + b.Append(','); + b.Append('['); + b.Append(typeArguments[i].ToString()); + b.Append(']'); + } + b.Append(']'); + return b.ToString(); + } + + int ISupportsInterning.GetHashCodeForInterning() + { + var hashCode = genericType.GetHashCode(); + unchecked + { + foreach (var t in typeArguments) + { + hashCode *= 27; + hashCode += t.GetHashCode(); + } + } + return hashCode; + } + + bool ISupportsInterning.EqualsForInterning(ISupportsInterning other) + { + var o = other as ParameterizedTypeReference; + if (o != null && genericType == o.genericType && typeArguments.Length == o.typeArguments.Length) + { + for (var i = 0; i < typeArguments.Length; i++) + { + if (typeArguments[i] != o.typeArguments[i]) + return false; + } + return true; + } + return false; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/PointerType.cs b/src/ICSharpCode.Decompiler/TypeSystem/PointerType.cs new file mode 100644 index 0000000..53d2960 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/PointerType.cs @@ -0,0 +1,108 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public sealed class PointerType : TypeWithElementType + { + public PointerType(IType elementType) : base(elementType) + { + } + + public override TypeKind Kind { + get { return TypeKind.Pointer; } + } + + public override string NameSuffix { + get { + return "*"; + } + } + + public override bool? IsReferenceType { + get { return null; } + } + + public override int GetHashCode() + { + return elementType.GetHashCode() ^ 91725811; + } + + public override bool Equals(IType other) + { + var a = other as PointerType; + return a != null && elementType.Equals(a.elementType); + } + + public override IType AcceptVisitor(TypeVisitor visitor) + { + return visitor.VisitPointerType(this); + } + + public override IType VisitChildren(TypeVisitor visitor) + { + var e = elementType.AcceptVisitor(visitor); + if (e == elementType) + return this; + else + return new PointerType(e); + } + } + + [Serializable] + public sealed class PointerTypeReference : ITypeReference, ISupportsInterning + { + readonly ITypeReference elementType; + + public PointerTypeReference(ITypeReference elementType) + { + if (elementType == null) + throw new ArgumentNullException(nameof(elementType)); + this.elementType = elementType; + } + + public ITypeReference ElementType { + get { return elementType; } + } + + public IType Resolve(ITypeResolveContext context) + { + return new PointerType(elementType.Resolve(context)); + } + + public override string ToString() + { + return elementType.ToString() + "*"; + } + + int ISupportsInterning.GetHashCodeForInterning() + { + return elementType.GetHashCode() ^ 91725812; + } + + bool ISupportsInterning.EqualsForInterning(ISupportsInterning other) + { + var o = other as PointerTypeReference; + return o != null && this.elementType == o.elementType; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ReferenceResolvingException.cs b/src/ICSharpCode.Decompiler/TypeSystem/ReferenceResolvingException.cs new file mode 100644 index 0000000..4b01374 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ReferenceResolvingException.cs @@ -0,0 +1,65 @@ +// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Represents an error while resolving a reference to a type or a member. + /// + [Serializable] + public class ReferenceResolvingException : Exception + { + /// + /// Initializes a new instance of the class + /// + public ReferenceResolvingException() + { + } + + /// + /// Initializes a new instance of the class + /// + /// A that describes the error. The content of message is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + public ReferenceResolvingException(string message) + : base(message) + { + } + + /// + /// Initializes a new instance of the class + /// + /// A that describes the error. The content of message is intended to be understood by humans. The caller of this constructor is required to ensure that this string has been localized for the current system culture. + /// The exception that is the cause of the current exception. If the innerException parameter is not a null reference, the current exception is raised in a catch block that handles the inner exception. + public ReferenceResolvingException(string message, Exception inner) + : base(message, inner) + { + } + + /// + /// Initializes a new instance of the class + /// + /// The object that holds the serialized object data. + /// The contextual information about the source or destination. + protected ReferenceResolvingException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) + : base(info, context) + { + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ReflectionHelper.cs b/src/ICSharpCode.Decompiler/TypeSystem/ReflectionHelper.cs new file mode 100644 index 0000000..cffe5ce --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ReflectionHelper.cs @@ -0,0 +1,502 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Static helper methods for reflection names. + /// + public static class ReflectionHelper + { + /// + /// A reflection class used to represent null. + /// + public sealed class Null { } + + /// + /// A reflection class used to represent dynamic. + /// + public sealed class Dynamic { } + + /// + /// A reflection class used to represent nint. + /// + public sealed class NInt { } + + /// + /// A reflection class used to represent nuint. + /// + public sealed class NUInt { } + + /// + /// A reflection class used to represent an unbound type argument. + /// + public sealed class UnboundTypeArgument { } + + #region ICompilation.FindType + /// + /// Retrieves the specified type in this compilation. + /// Returns if the type cannot be found in this compilation. + /// + /// + /// This method cannot be used with open types; all type parameters will be substituted + /// with . + /// + public static IType FindType(this ICompilation compilation, Type type) + { + return type.ToTypeReference().Resolve(new SimpleTypeResolveContext(compilation)); + } + #endregion + + #region Type.ToTypeReference() + /// + /// Creates a reference to the specified type. + /// + /// The type to be converted. + /// Returns the type reference. + /// + /// If the type is open (contains type parameters '`0' or '``0'), + /// an with the appropriate CurrentTypeDefinition/CurrentMember is required + /// to resolve the type reference. + /// For closed types, the root type resolve context for the compilation is sufficient. + /// + public static ITypeReference ToTypeReference(this Type type) + { + if (type == null) + return SpecialType.UnknownType; + if (type.IsGenericType && !type.IsGenericTypeDefinition) + { + var def = ToTypeReference(type.GetGenericTypeDefinition()); + var arguments = type.GetGenericArguments(); + var args = new ITypeReference[arguments.Length]; + var allUnbound = true; + for (var i = 0; i < arguments.Length; i++) + { + args[i] = ToTypeReference(arguments[i]); + allUnbound &= args[i].Equals(SpecialType.UnboundTypeArgument); + } + if (allUnbound) + return def; + else + return new ParameterizedTypeReference(def, args); + } + else if (type.IsArray) + { + return new ArrayTypeReference(ToTypeReference(type.GetElementType()), type.GetArrayRank()); + } + else if (type.IsPointer) + { + return new PointerTypeReference(ToTypeReference(type.GetElementType())); + } + else if (type.IsByRef) + { + return new ByReferenceTypeReference(ToTypeReference(type.GetElementType())); + } + else if (type.IsGenericParameter) + { + if (type.DeclaringMethod != null) + { + return TypeParameterReference.Create(SymbolKind.Method, type.GenericParameterPosition); + } + else + { + return TypeParameterReference.Create(SymbolKind.TypeDefinition, type.GenericParameterPosition); + } + } + else if (type.DeclaringType != null) + { + if (type == typeof(Dynamic)) + return SpecialType.Dynamic; + else if (type == typeof(NInt)) + return SpecialType.NInt; + else if (type == typeof(NUInt)) + return SpecialType.NUInt; + else if (type == typeof(Null)) + return SpecialType.NullType; + else if (type == typeof(UnboundTypeArgument)) + return SpecialType.UnboundTypeArgument; + var baseTypeRef = ToTypeReference(type.DeclaringType); + int typeParameterCount; + var name = SplitTypeParameterCountFromReflectionName(type.Name, out typeParameterCount); + return new NestedTypeReference(baseTypeRef, name, typeParameterCount); + } + else + { + IModuleReference assemblyReference = new DefaultAssemblyReference(type.Assembly.FullName); + int typeParameterCount; + var name = SplitTypeParameterCountFromReflectionName(type.Name, out typeParameterCount); + return new GetClassTypeReference(assemblyReference, type.Namespace, name, typeParameterCount); + } + } + #endregion + + #region SplitTypeParameterCountFromReflectionName + /// + /// Removes the ` with type parameter count from the reflection name. + /// + /// Do not use this method with the full name of inner classes. + public static string SplitTypeParameterCountFromReflectionName(string reflectionName) + { + var pos = reflectionName.LastIndexOf('`'); + if (pos < 0) + { + return reflectionName; + } + else + { + return reflectionName.Substring(0, pos); + } + } + + /// + /// Removes the ` with type parameter count from the reflection name. + /// + /// Do not use this method with the full name of inner classes. + public static string SplitTypeParameterCountFromReflectionName(string reflectionName, out int typeParameterCount) + { + var pos = reflectionName.LastIndexOf('`'); + if (pos < 0) + { + typeParameterCount = 0; + return reflectionName; + } + else + { + var typeCount = reflectionName.Substring(pos + 1); + if (int.TryParse(typeCount, out typeParameterCount)) + return reflectionName.Substring(0, pos); + else + return reflectionName; + } + } + #endregion + + #region TypeCode support + /// + /// Retrieves a built-in type using the specified type code. + /// + public static IType FindType(this ICompilation compilation, TypeCode typeCode) + { + return compilation.FindType((KnownTypeCode)typeCode); + } + + /// + /// Creates a reference to the specified type. + /// + /// The type to be converted. + /// Returns the type reference. + public static ITypeReference ToTypeReference(this TypeCode typeCode) + { + return KnownTypeReference.Get((KnownTypeCode)typeCode); + } + + /// + /// Gets the type code for the specified type, or TypeCode.Empty if none of the other type codes match. + /// + public static TypeCode GetTypeCode(this IType type) + { + var def = type as ITypeDefinition; + if (def != null) + { + var typeCode = def.KnownTypeCode; + if (typeCode <= KnownTypeCode.String && typeCode != KnownTypeCode.Void) + return (TypeCode)typeCode; + else + return TypeCode.Empty; + } + return TypeCode.Empty; + } + #endregion + + #region ParseReflectionName + /// + /// Parses a reflection name into a type reference. + /// + /// The reflection name of the type. + /// A type reference that represents the reflection name. + /// The syntax of the reflection type name is invalid + /// + /// If the type is open (contains type parameters '`0' or '``0'), + /// an with the appropriate CurrentTypeDefinition/CurrentMember is required + /// to resolve the reference to the ITypeParameter. + /// For looking up closed, assembly qualified type names, the root type resolve context for the compilation + /// is sufficient. + /// When looking up a type name that isn't assembly qualified, the type reference will look in + /// first, and if the type is not found there, + /// it will look in all other assemblies of the compilation. + /// + /// + public static ITypeReference ParseReflectionName(string reflectionTypeName) + { + if (reflectionTypeName == null) + throw new ArgumentNullException(nameof(reflectionTypeName)); + var pos = 0; + var r = ParseReflectionName(reflectionTypeName, ref pos); + if (pos < reflectionTypeName.Length) + throw new ReflectionNameParseException(pos, "Expected end of type name"); + return r; + } + + static bool IsReflectionNameSpecialCharacter(char c) + { + switch (c) + { + case '+': + case '`': + case '[': + case ']': + case ',': + case '*': + case '&': + return true; + default: + return false; + } + } + + /// + /// Parses the reflection name starting at pos. + /// If local is true, only parses local type names, not assembly qualified type names. + /// + static ITypeReference ParseReflectionName(string reflectionTypeName, ref int pos, bool local = false) + { + if (pos == reflectionTypeName.Length) + throw new ReflectionNameParseException(pos, "Unexpected end"); + ITypeReference reference; + if (reflectionTypeName[pos] == '`') + { + // type parameter reference + pos++; + if (pos == reflectionTypeName.Length) + throw new ReflectionNameParseException(pos, "Unexpected end"); + if (reflectionTypeName[pos] == '`') + { + // method type parameter reference + pos++; + var index = ReadTypeParameterCount(reflectionTypeName, ref pos); + reference = TypeParameterReference.Create(SymbolKind.Method, index); + } + else + { + // class type parameter reference + var index = ReadTypeParameterCount(reflectionTypeName, ref pos); + reference = TypeParameterReference.Create(SymbolKind.TypeDefinition, index); + } + } + else + { + // not a type parameter reference: read the actual type name + var typeName = ReadTypeName(reflectionTypeName, ref pos, out var tpc); + var assemblyName = local ? null : SkipAheadAndReadAssemblyName(reflectionTypeName, pos); + reference = CreateGetClassTypeReference(assemblyName, typeName, tpc); + } + // read type suffixes + while (pos < reflectionTypeName.Length) + { + switch (reflectionTypeName[pos++]) + { + case '+': + int tpc; + var typeName = ReadTypeName(reflectionTypeName, ref pos, out tpc); + reference = new NestedTypeReference(reference, typeName, tpc); + break; + case '*': + reference = new PointerTypeReference(reference); + break; + case '&': + reference = new ByReferenceTypeReference(reference); + break; + case '[': + // this might be an array or a generic type + if (pos == reflectionTypeName.Length) + throw new ReflectionNameParseException(pos, "Unexpected end"); + if (reflectionTypeName[pos] != ']' && reflectionTypeName[pos] != ',') + { + // it's a generic type + var typeArguments = new List(); + var first = true; + while (first || pos < reflectionTypeName.Length && reflectionTypeName[pos] == ',') + { + if (first) + { + first = false; + } + else + { + pos++; // skip ',' + } + if (pos < reflectionTypeName.Length && reflectionTypeName[pos] == '[') + { + // non-local type names are enclosed in another set of [] + pos++; + + typeArguments.Add(ParseReflectionName(reflectionTypeName, ref pos)); + + if (pos < reflectionTypeName.Length && reflectionTypeName[pos] == ']') + pos++; + else + throw new ReflectionNameParseException(pos, "Expected end of type argument"); + } + else + { + // local type names occur directly in the outer [] + typeArguments.Add(ParseReflectionName(reflectionTypeName, ref pos, local: true)); + } + } + + if (pos < reflectionTypeName.Length && reflectionTypeName[pos] == ']') + { + pos++; + reference = new ParameterizedTypeReference(reference, typeArguments); + } + else + { + throw new ReflectionNameParseException(pos, "Expected end of generic type"); + } + } + else + { + // it's an array + var dimensions = 1; + while (pos < reflectionTypeName.Length && reflectionTypeName[pos] == ',') + { + dimensions++; + pos++; + } + if (pos < reflectionTypeName.Length && reflectionTypeName[pos] == ']') + { + pos++; // end of array + reference = new ArrayTypeReference(reference, dimensions); + } + else + { + throw new ReflectionNameParseException(pos, "Invalid array modifier"); + } + } + break; + case ',' when !local: + // assembly qualified name, ignore everything up to the end/next ']' + while (pos < reflectionTypeName.Length && reflectionTypeName[pos] != ']') + pos++; + break; + default: + pos--; // reset pos to the character we couldn't read + if (reflectionTypeName[pos] == ']' || reflectionTypeName[pos] == ',') + return reference; // return from a nested generic + else + throw new ReflectionNameParseException(pos, "Unexpected character: '" + reflectionTypeName[pos] + "'"); + } + } + return reference; + } + + static ITypeReference CreateGetClassTypeReference(string assemblyName, string typeName, int tpc) + { + IModuleReference assemblyReference; + if (assemblyName != null) + { + assemblyReference = new DefaultAssemblyReference(assemblyName); + } + else + { + assemblyReference = null; + } + var pos = typeName.LastIndexOf('.'); + if (pos < 0) + return new GetClassTypeReference(assemblyReference, string.Empty, typeName, tpc); + else + return new GetClassTypeReference(assemblyReference, typeName.Substring(0, pos), typeName.Substring(pos + 1), tpc); + } + + static string SkipAheadAndReadAssemblyName(string reflectionTypeName, int pos) + { + var nestingLevel = 0; + while (pos < reflectionTypeName.Length) + { + switch (reflectionTypeName[pos++]) + { + case '[': + nestingLevel++; + break; + case ']': + if (nestingLevel == 0) + return null; + nestingLevel--; + break; + case ',': + if (nestingLevel == 0) + { + // first skip the whitespace + while (pos < reflectionTypeName.Length && reflectionTypeName[pos] == ' ') + pos++; + // everything up to the end/next ']' is the assembly name + var endPos = pos; + while (endPos < reflectionTypeName.Length && reflectionTypeName[endPos] != ']') + endPos++; + return reflectionTypeName.Substring(pos, endPos - pos); + } + break; + } + } + return null; + } + + static string ReadTypeName(string reflectionTypeName, ref int pos, out int tpc) + { + var startPos = pos; + // skip the simple name portion: + while (pos < reflectionTypeName.Length && !IsReflectionNameSpecialCharacter(reflectionTypeName[pos])) + pos++; + if (pos == startPos) + throw new ReflectionNameParseException(pos, "Expected type name"); + var typeName = reflectionTypeName.Substring(startPos, pos - startPos); + if (pos < reflectionTypeName.Length && reflectionTypeName[pos] == '`') + { + pos++; + tpc = ReadTypeParameterCount(reflectionTypeName, ref pos); + } + else + { + tpc = 0; + } + return typeName; + } + + internal static int ReadTypeParameterCount(string reflectionTypeName, ref int pos) + { + var startPos = pos; + while (pos < reflectionTypeName.Length) + { + var c = reflectionTypeName[pos]; + if (c < '0' || c > '9') + break; + pos++; + } + int tpc; + if (!int.TryParse(reflectionTypeName.Substring(startPos, pos - startPos), out tpc)) + throw new ReflectionNameParseException(pos, "Expected type parameter count"); + return tpc; + } + #endregion + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/ReflectionNameParseException.cs b/src/ICSharpCode.Decompiler/TypeSystem/ReflectionNameParseException.cs new file mode 100644 index 0000000..2618d44 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/ReflectionNameParseException.cs @@ -0,0 +1,63 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Runtime.Serialization; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Represents an error while parsing a reflection name. + /// + [Serializable] + public class ReflectionNameParseException : Exception + { + int position; + + public int Position { + get { return position; } + } + + public ReflectionNameParseException(int position) + { + this.position = position; + } + + public ReflectionNameParseException(int position, string message) : base(message) + { + this.position = position; + } + + public ReflectionNameParseException(int position, string message, Exception innerException) : base(message, innerException) + { + this.position = position; + } + + // This constructor is needed for serialization. + protected ReflectionNameParseException(SerializationInfo info, StreamingContext context) : base(info, context) + { + position = info.GetInt32("position"); + } + + public override void GetObjectData(SerializationInfo info, StreamingContext context) + { + base.GetObjectData(info, context); + info.AddValue("position", position); + } + } +} \ No newline at end of file diff --git a/src/ICSharpCode.Decompiler/TypeSystem/SimpleTypeResolveContext.cs b/src/ICSharpCode.Decompiler/TypeSystem/SimpleTypeResolveContext.cs new file mode 100644 index 0000000..782de8d --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/SimpleTypeResolveContext.cs @@ -0,0 +1,92 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Default ITypeResolveContext implementation. + /// + public class SimpleTypeResolveContext : ITypeResolveContext + { + readonly ICompilation compilation; + readonly IModule currentModule; + readonly ITypeDefinition currentTypeDefinition; + readonly IMember currentMember; + + public SimpleTypeResolveContext(ICompilation compilation) + { + if (compilation == null) + throw new ArgumentNullException(nameof(compilation)); + this.compilation = compilation; + } + + public SimpleTypeResolveContext(IModule module) + { + if (module == null) + throw new ArgumentNullException(nameof(module)); + this.compilation = module.Compilation; + this.currentModule = module; + } + + public SimpleTypeResolveContext(IEntity entity) + { + if (entity == null) + throw new ArgumentNullException(nameof(entity)); + this.compilation = entity.Compilation; + this.currentModule = entity.ParentModule; + this.currentTypeDefinition = (entity as ITypeDefinition) ?? entity.DeclaringTypeDefinition; + this.currentMember = entity as IMember; + } + + private SimpleTypeResolveContext(ICompilation compilation, IModule currentModule, ITypeDefinition currentTypeDefinition, IMember currentMember) + { + this.compilation = compilation; + this.currentModule = currentModule; + this.currentTypeDefinition = currentTypeDefinition; + this.currentMember = currentMember; + } + + public ICompilation Compilation { + get { return compilation; } + } + + public IModule CurrentModule { + get { return currentModule; } + } + + public ITypeDefinition CurrentTypeDefinition { + get { return currentTypeDefinition; } + } + + public IMember CurrentMember { + get { return currentMember; } + } + + public ITypeResolveContext WithCurrentTypeDefinition(ITypeDefinition typeDefinition) + { + return new SimpleTypeResolveContext(compilation, currentModule, typeDefinition, currentMember); + } + + public ITypeResolveContext WithCurrentMember(IMember member) + { + return new SimpleTypeResolveContext(compilation, currentModule, currentTypeDefinition, member); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/SpecialType.cs b/src/ICSharpCode.Decompiler/TypeSystem/SpecialType.cs new file mode 100644 index 0000000..12601f9 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/SpecialType.cs @@ -0,0 +1,124 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Contains static implementations of special types. + /// + [Serializable] + public sealed class SpecialType : AbstractType, ITypeReference + { + /// + /// Gets the type representing resolve errors. + /// + public readonly static SpecialType UnknownType = new SpecialType(TypeKind.Unknown, "?", isReferenceType: null); + + /// + /// The null type is used as type of the null literal. It is a reference type without any members; and it is a subtype of all reference types. + /// + public readonly static SpecialType NullType = new SpecialType(TypeKind.Null, "null", isReferenceType: true); + + /// + /// Used for expressions without type, e.g. method groups or lambdas. + /// + public readonly static SpecialType NoType = new SpecialType(TypeKind.None, "?", isReferenceType: null); + + /// + /// Type representing the C# 'dynamic' type. + /// + public readonly static SpecialType Dynamic = new SpecialType(TypeKind.Dynamic, "dynamic", isReferenceType: true); + + /// + /// Type representing the C# 9 'nint' type. + /// + public readonly static SpecialType NInt = new SpecialType(TypeKind.NInt, "nint", isReferenceType: false); + + /// + /// Type representing the C# 9 'nuint' type. + /// + public readonly static SpecialType NUInt = new SpecialType(TypeKind.NUInt, "nuint", isReferenceType: false); + + /// + /// Type representing the result of the C# '__arglist()' expression. + /// + public readonly static SpecialType ArgList = new SpecialType(TypeKind.ArgList, "__arglist", isReferenceType: null); + + /// + /// A type used for unbound type arguments in partially parameterized types. + /// + /// + public readonly static SpecialType UnboundTypeArgument = new SpecialType(TypeKind.UnboundTypeArgument, "", isReferenceType: null); + + readonly TypeKind kind; + readonly string name; + readonly bool? isReferenceType; + + private SpecialType(TypeKind kind, string name, bool? isReferenceType) + { + this.kind = kind; + this.name = name; + this.isReferenceType = isReferenceType; + } + + public override string Name { + get { return name; } + } + + public override TypeKind Kind { + get { return kind; } + } + + public override bool? IsReferenceType { + get { return isReferenceType; } + } + + IType ITypeReference.Resolve(ITypeResolveContext context) + { + if (context == null) + throw new ArgumentNullException(nameof(context)); + return this; + } + +#pragma warning disable 809 + [Obsolete("Please compare special types using the kind property instead.")] + public override bool Equals(IType other) + { + // We consider a special types equal when they have equal types. + // However, an unknown type with additional information is not considered to be equal to the SpecialType with TypeKind.Unknown. + return other is SpecialType && other.Kind == kind; + } + + public override int GetHashCode() + { + return 81625621 ^ (int)kind; + } + + public override IType ChangeNullability(Nullability nullability) + { + if (nullability == base.Nullability) + return this; + else + return new NullabilityAnnotatedType(this, nullability); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/TaskType.cs b/src/ICSharpCode.Decompiler/TypeSystem/TaskType.cs new file mode 100644 index 0000000..095791b --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/TaskType.cs @@ -0,0 +1,144 @@ +// Copyright (c) 2010-2014 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Helper class for dealing with System.Threading.Tasks.Task. + /// + public static class TaskType + { + /// + /// Gets the T in Task<T>. + /// Returns void for non-generic Task. + /// Any other type is returned unmodified. + /// + public static IType UnpackTask(ICompilation compilation, IType type) + { + if (!IsTask(type)) + return type; + if (type.TypeParameterCount == 0) + return compilation.FindType(KnownTypeCode.Void); + else + return type.TypeArguments[0]; + } + + /// + /// Gets whether the specified type is Task or Task<T>. + /// + public static bool IsTask(IType type) + { + var def = type.GetDefinition(); + if (def != null) + { + if (def.KnownTypeCode == KnownTypeCode.Task) + return true; + if (def.KnownTypeCode == KnownTypeCode.TaskOfT) + return type is ParameterizedType; + } + return false; + } + + /// + /// Gets whether the specified type is a Task-like type. + /// + public static bool IsCustomTask(IType type, out IType builderType) + { + builderType = null; + var def = type.GetDefinition(); + if (def != null) + { + if (def.TypeParameterCount > 1) + return false; + var attribute = def.GetAttribute(KnownAttribute.AsyncMethodBuilder); + if (attribute == null || attribute.FixedArguments.Length != 1) + return false; + var arg = attribute.FixedArguments[0]; + if (!arg.Type.IsKnownType(KnownTypeCode.Type)) + return false; + builderType = (IType)arg.Value; + return true; + } + return false; + } + + const string ns = "System.Runtime.CompilerServices"; + + /// + /// Gets whether the specified type is a non-generic Task-like type. + /// + /// Returns the full type-name of the builder type, if successful. + public static bool IsNonGenericTaskType(IType task, out FullTypeName builderTypeName) + { + if (task.IsKnownType(KnownTypeCode.Task)) + { + builderTypeName = new TopLevelTypeName(ns, "AsyncTaskMethodBuilder"); + return true; + } + if (IsCustomTask(task, out var builderType)) + { + builderTypeName = new FullTypeName(builderType.ReflectionName); + return builderTypeName.TypeParameterCount == 0; + } + builderTypeName = default; + return false; + } + + /// + /// Gets whether the specified type is a generic Task-like type. + /// + /// Returns the full type-name of the builder type, if successful. + public static bool IsGenericTaskType(IType task, out FullTypeName builderTypeName) + { + if (task.IsKnownType(KnownTypeCode.TaskOfT)) + { + builderTypeName = new TopLevelTypeName(ns, "AsyncTaskMethodBuilder", 1); + return true; + } + if (IsCustomTask(task, out var builderType)) + { + builderTypeName = new FullTypeName(builderType.ReflectionName); + return builderTypeName.TypeParameterCount == 1; + } + builderTypeName = default; + return false; + } + + /// + /// Creates a task type. + /// + public static IType Create(ICompilation compilation, IType elementType) + { + if (compilation == null) + throw new ArgumentNullException(nameof(compilation)); + if (elementType == null) + throw new ArgumentNullException(nameof(elementType)); + + if (elementType.Kind == TypeKind.Void) + return compilation.FindType(KnownTypeCode.Task); + var taskType = compilation.FindType(KnownTypeCode.TaskOfT); + var taskTypeDef = taskType.GetDefinition(); + if (taskTypeDef != null) + return new ParameterizedType(taskTypeDef, new[] { elementType }); + else + return taskType; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/TopLevelTypeName.cs b/src/ICSharpCode.Decompiler/TypeSystem/TopLevelTypeName.cs new file mode 100644 index 0000000..738e761 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/TopLevelTypeName.cs @@ -0,0 +1,149 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Text; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Holds the name of a top-level type. + /// This struct cannot refer to nested classes. + /// + [Serializable] + public readonly struct TopLevelTypeName : IEquatable + { + readonly string namespaceName; + readonly string name; + readonly int typeParameterCount; + + public TopLevelTypeName(string namespaceName, string name, int typeParameterCount = 0) + { + if (namespaceName == null) + throw new ArgumentNullException(nameof(namespaceName)); + if (name == null) + throw new ArgumentNullException(nameof(name)); + this.namespaceName = namespaceName; + this.name = name; + this.typeParameterCount = typeParameterCount; + } + + public TopLevelTypeName(string reflectionName) + { + var pos = reflectionName.LastIndexOf('.'); + if (pos < 0) + { + namespaceName = string.Empty; + name = reflectionName; + } + else + { + namespaceName = reflectionName.Substring(0, pos); + name = reflectionName.Substring(pos + 1); + } + name = ReflectionHelper.SplitTypeParameterCountFromReflectionName(name, out typeParameterCount); + } + + public string Namespace { + get { return namespaceName; } + } + + public string Name { + get { return name; } + } + + public int TypeParameterCount { + get { return typeParameterCount; } + } + + public string ReflectionName { + get { + var b = new StringBuilder(); + if (!string.IsNullOrEmpty(namespaceName)) + { + b.Append(namespaceName); + b.Append('.'); + } + b.Append(name); + if (typeParameterCount > 0) + { + b.Append('`'); + b.Append(typeParameterCount); + } + return b.ToString(); + } + } + + public override string ToString() + { + return this.ReflectionName; + } + + public override bool Equals(object obj) + { + return (obj is TopLevelTypeName) && Equals((TopLevelTypeName)obj); + } + + public bool Equals(TopLevelTypeName other) + { + return this.namespaceName == other.namespaceName && this.name == other.name && this.typeParameterCount == other.typeParameterCount; + } + + public override int GetHashCode() + { + return (name != null ? name.GetHashCode() : 0) ^ (namespaceName != null ? namespaceName.GetHashCode() : 0) ^ typeParameterCount; + } + + public static bool operator ==(TopLevelTypeName lhs, TopLevelTypeName rhs) + { + return lhs.Equals(rhs); + } + + public static bool operator !=(TopLevelTypeName lhs, TopLevelTypeName rhs) + { + return !lhs.Equals(rhs); + } + } + + [Serializable] + public sealed class TopLevelTypeNameComparer : IEqualityComparer + { + public static readonly TopLevelTypeNameComparer Ordinal = new TopLevelTypeNameComparer(StringComparer.Ordinal); + public static readonly TopLevelTypeNameComparer OrdinalIgnoreCase = new TopLevelTypeNameComparer(StringComparer.OrdinalIgnoreCase); + + public readonly StringComparer NameComparer; + + public TopLevelTypeNameComparer(StringComparer nameComparer) + { + this.NameComparer = nameComparer; + } + + public bool Equals(TopLevelTypeName x, TopLevelTypeName y) + { + return x.TypeParameterCount == y.TypeParameterCount + && NameComparer.Equals(x.Name, y.Name) + && NameComparer.Equals(x.Namespace, y.Namespace); + } + + public int GetHashCode(TopLevelTypeName obj) + { + return NameComparer.GetHashCode(obj.Name) ^ NameComparer.GetHashCode(obj.Namespace) ^ obj.TypeParameterCount; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/TupleType.cs b/src/ICSharpCode.Decompiler/TypeSystem/TupleType.cs new file mode 100644 index 0000000..6f2baf3 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/TupleType.cs @@ -0,0 +1,419 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Linq; +using System.Text; + +using ICSharpCode.Decompiler.TypeSystem.Implementation; +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public sealed class TupleType : AbstractType, ICompilationProvider + { + public const int RestPosition = 8; + const int RestIndex = RestPosition - 1; + + public ICompilation Compilation { get; } + + /// + /// Gets the underlying System.ValueType type. + /// + public ParameterizedType UnderlyingType { get; } + + /// + /// Gets the tuple elements. + /// + public ImmutableArray ElementTypes { get; } + + /// + /// Gets the cardinality of the tuple. + /// + public int Cardinality => ElementTypes.Length; + + /// + /// Gets the names of the tuple elements. + /// + public ImmutableArray ElementNames { get; } + + public TupleType(ICompilation compilation, ImmutableArray elementTypes, + ImmutableArray elementNames = default(ImmutableArray), + IModule valueTupleAssembly = null) + { + this.Compilation = compilation; + this.UnderlyingType = CreateUnderlyingType(compilation, elementTypes, valueTupleAssembly); + this.ElementTypes = elementTypes; + if (elementNames.IsDefault) + { + this.ElementNames = Enumerable.Repeat(null, elementTypes.Length).ToImmutableArray(); + } + else + { + Debug.Assert(elementNames.Length == elementTypes.Length); + this.ElementNames = elementNames; + } + } + + static ParameterizedType CreateUnderlyingType(ICompilation compilation, ImmutableArray elementTypes, IModule valueTupleAssembly) + { + var remainder = (elementTypes.Length - 1) % (RestPosition - 1) + 1; + Debug.Assert(remainder >= 1 && remainder < RestPosition); + var pos = elementTypes.Length - remainder; + var type = new ParameterizedType( + FindValueTupleType(compilation, valueTupleAssembly, remainder), + elementTypes.Slice(pos)); + while (pos > 0) + { + pos -= (RestPosition - 1); + type = new ParameterizedType( + FindValueTupleType(compilation, valueTupleAssembly, RestPosition), + elementTypes.Slice(pos, RestPosition - 1).Concat(new[] { type })); + } + Debug.Assert(pos == 0); + return type; + } + + private static IType FindValueTupleType(ICompilation compilation, IModule valueTupleAssembly, int tpc) + { + var typeName = new TopLevelTypeName("System", "ValueTuple", tpc); + if (valueTupleAssembly != null) + { + var typeDef = valueTupleAssembly.GetTypeDefinition(typeName); + if (typeDef != null) + return typeDef; + } + return compilation.FindType(typeName); + } + + /// + /// Gets whether the specified type is a valid underlying type for a tuple. + /// Also returns true for tuple types themselves. + /// + public static bool IsTupleCompatible(IType type, out int tupleCardinality) + { + switch (type.Kind) + { + case TypeKind.Tuple: + tupleCardinality = ((TupleType)type).ElementTypes.Length; + return true; + case TypeKind.Class: + case TypeKind.Struct: + if (type.Namespace == "System" && type.Name == "ValueTuple") + { + var tpc = type.TypeParameterCount; + if (tpc > 0 && tpc < RestPosition) + { + tupleCardinality = tpc; + return true; + } + else if (tpc == RestPosition && type is ParameterizedType pt) + { + if (IsTupleCompatible(pt.TypeArguments[RestIndex], out tupleCardinality)) + { + tupleCardinality += RestPosition - 1; + return true; + } + } + } + break; + } + tupleCardinality = 0; + return false; + } + + /// + /// Construct a tuple type (without element names) from the given underlying type. + /// Returns null if the input is not a valid underlying type. + /// + public static TupleType FromUnderlyingType(ICompilation compilation, IType type) + { + var elementTypes = GetTupleElementTypes(type); + if (elementTypes.Length > 0) + { + return new TupleType( + compilation, + elementTypes, + valueTupleAssembly: type.GetDefinition()?.ParentModule + ); + } + else + { + return null; + } + } + + /// + /// Gets the tuple element types from a tuple type or tuple underlying type. + /// + public static ImmutableArray GetTupleElementTypes(IType tupleType) + { + List output = null; + if (Collect(tupleType)) + { + return output.ToImmutableArray(); + } + else + { + return default(ImmutableArray); + } + + bool Collect(IType type) + { + switch (type.Kind) + { + case TypeKind.Tuple: + if (output == null) + output = new List(); + output.AddRange(((TupleType)type).ElementTypes); + return true; + case TypeKind.Class: + case TypeKind.Struct: + if (type.Namespace == "System" && type.Name == "ValueTuple") + { + if (output == null) + output = new List(); + var tpc = type.TypeParameterCount; + if (tpc > 0 && tpc < RestPosition) + { + output.AddRange(type.TypeArguments); + return true; + } + else if (tpc == RestPosition) + { + output.AddRange(type.TypeArguments.Take(RestPosition - 1)); + return Collect(type.TypeArguments[RestIndex]); + } + } + break; + } + return false; + } + } + + public override TypeKind Kind => TypeKind.Tuple; + public override bool? IsReferenceType => UnderlyingType.IsReferenceType; + public override int TypeParameterCount => 0; + public override IReadOnlyList TypeParameters => EmptyList.Instance; + public override IReadOnlyList TypeArguments => EmptyList.Instance; + public override IEnumerable DirectBaseTypes => UnderlyingType.DirectBaseTypes; + public override string FullName => UnderlyingType.FullName; + public override string Name => UnderlyingType.Name; + public override string ReflectionName => UnderlyingType.ReflectionName; + public override string Namespace => UnderlyingType.Namespace; + + public override bool Equals(IType other) + { + var o = other as TupleType; + if (o == null) + return false; + if (!UnderlyingType.Equals(o.UnderlyingType)) + return false; + return UnderlyingType.Equals(o.UnderlyingType) + && ElementNames.SequenceEqual(o.ElementNames); + } + + public override int GetHashCode() + { + unchecked + { + var hash = UnderlyingType.GetHashCode(); + foreach (var name in ElementNames) + { + hash *= 31; + hash += name != null ? name.GetHashCode() : 0; + } + return hash; + } + } + + public override string ToString() + { + var b = new StringBuilder(); + b.Append('('); + for (var i = 0; i < ElementTypes.Length; i++) + { + if (i > 0) + b.Append(", "); + b.Append(ElementTypes[i]); + if (ElementNames[i] != null) + { + b.Append(' '); + b.Append(ElementNames[i]); + } + } + b.Append(')'); + return b.ToString(); + } + + public override IType AcceptVisitor(TypeVisitor visitor) + { + return visitor.VisitTupleType(this); + } + + public override IType VisitChildren(TypeVisitor visitor) + { + IType[] newElementTypes = null; + for (var i = 0; i < ElementTypes.Length; i++) + { + var type = ElementTypes[i]; + var newType = type.AcceptVisitor(visitor); + if (newType != type) + { + if (newElementTypes == null) + { + newElementTypes = ElementTypes.ToArray(); + } + newElementTypes[i] = newType; + } + } + if (newElementTypes != null) + { + return new TupleType(this.Compilation, newElementTypes.ToImmutableArray(), this.ElementNames, + this.GetDefinition()?.ParentModule); + } + else + { + return this; + } + } + + public override IEnumerable GetAccessors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return UnderlyingType.GetAccessors(filter, options); + } + + public override IEnumerable GetConstructors(Predicate filter = null, GetMemberOptions options = GetMemberOptions.IgnoreInheritedMembers) + { + // CS8181 'new' cannot be used with tuple type. Use a tuple literal expression instead. + return EmptyList.Instance; + } + + public override ITypeDefinition GetDefinition() + { + return UnderlyingType.GetDefinition(); + } + + public override IEnumerable GetEvents(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return UnderlyingType.GetEvents(filter, options); + } + + public override IEnumerable GetFields(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + // The fields from the underlying type (Item1..Item7 and Rest) + foreach (var field in UnderlyingType.GetFields(filter, options)) + { + yield return field; + } + /*for (int i = 0; i < ElementTypes.Length; i++) { + var type = ElementTypes[i]; + var name = ElementNames[i]; + int pos = i + 1; + string itemName = "Item" + pos; + if (name != itemName && name != null) + yield return MakeField(type, name); + if (pos >= RestPosition) + yield return MakeField(type, itemName); + }*/ + } + + /*private IField MakeField(IType type, string name) + { + var f = new DefaultUnresolvedField(); + f.ReturnType = SpecialType.UnknownType; + f.Name = name; + return new TupleElementField(f, Compilation.TypeResolveContext); + }*/ + + public override IEnumerable GetMethods(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return UnderlyingType.GetMethods(filter, options); + } + + public override IEnumerable GetMethods(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return UnderlyingType.GetMethods(typeArguments, filter, options); + } + + public override IEnumerable GetNestedTypes(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return UnderlyingType.GetNestedTypes(filter, options); + } + + public override IEnumerable GetNestedTypes(IReadOnlyList typeArguments, Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return UnderlyingType.GetNestedTypes(typeArguments, filter, options); + } + + public override IEnumerable GetProperties(Predicate filter = null, GetMemberOptions options = GetMemberOptions.None) + { + return UnderlyingType.GetProperties(filter, options); + } + } + + public class TupleTypeReference : ITypeReference + { + /// + /// Gets the types of the tuple elements. + /// + public ImmutableArray ElementTypes { get; } + + /// + /// Gets the names of the tuple elements. + /// + public ImmutableArray ElementNames { get; } + + public IModuleReference ValueTupleAssembly { get; } + + public TupleTypeReference(ImmutableArray elementTypes) + { + this.ElementTypes = elementTypes; + } + + public TupleTypeReference(ImmutableArray elementTypes, + ImmutableArray elementNames = default(ImmutableArray), + IModuleReference valueTupleAssembly = null) + { + this.ValueTupleAssembly = valueTupleAssembly; + this.ElementTypes = elementTypes; + this.ElementNames = elementNames; + } + + public IType Resolve(ITypeResolveContext context) + { + return new TupleType(context.Compilation, + ElementTypes.Select(t => t.Resolve(context)).ToImmutableArray(), + ElementNames, + ValueTupleAssembly?.Resolve(context) + ); + } + } + + public static class TupleTypeExtensions + { + public static IType TupleUnderlyingTypeOrSelf(this IType type) + { + var t = (type as TupleType)?.UnderlyingType ?? type; + return t.WithoutNullability(); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/TypeKind.cs b/src/ICSharpCode.Decompiler/TypeSystem/TypeKind.cs new file mode 100644 index 0000000..2e4c360 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/TypeKind.cs @@ -0,0 +1,112 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// . + /// + public enum TypeKind : byte + { + /// Language-specific type that is not part of NRefactory.TypeSystem itself. + Other, + + /// A or that is a class. + Class, + /// A or that is an interface. + Interface, + /// A or that is a struct. + Struct, + /// A or that is a delegate. + /// System.Delegate itself is TypeKind.Class + Delegate, + /// A that is an enum. + /// System.Enum itself is TypeKind.Class + Enum, + + /// The System.Void type. + /// + Void, + + /// Type used for invalid expressions and for types whose definition could not be found. + /// + Unknown, + /// The type of the null literal. + /// + Null, + /// The type of expressions without type (except for null literals, which have TypeKind.Null). + /// + None, + /// Type representing the C# 'dynamic' type. + /// + Dynamic, + /// Represents missing type arguments in partially parameterized types. + /// + /// IType.GetNestedTypes(Predicate{ITypeDefinition}, GetMemberOptions) + UnboundTypeArgument, + + /// The type is a type parameter. + /// + TypeParameter, + + /// An array type + /// + Array, + /// A pointer type + /// + Pointer, + /// A managed reference type + /// + ByReference, + + /// Intersection of several types + /// + Intersection, + /// + ArgList, + /// A C# 7 tuple type. + /// E.g. (string, int) + /// Note: System.ValueTuple<string, int> is not considered a tuple type. + /// + /// + Tuple, + /// + /// Modified type, with optional modifier. + /// + ModOpt, + /// + /// Modified type, with required modifier. + /// + ModReq, + + /// + /// C# 9 nint + /// + NInt, + /// + /// C# 9 nuint + /// + NUInt, + + /// + /// C# 9 delegate* + /// + FunctionPointer, + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/TypeParameterSubstitution.cs b/src/ICSharpCode.Decompiler/TypeSystem/TypeParameterSubstitution.cs new file mode 100644 index 0000000..ea74c1d --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/TypeParameterSubstitution.cs @@ -0,0 +1,276 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Text; + +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Substitutes class and method type parameters. + /// + public class TypeParameterSubstitution : TypeVisitor + { + /// + /// The identity function. + /// + public static readonly TypeParameterSubstitution Identity = new TypeParameterSubstitution(null, null); + + readonly IReadOnlyList classTypeArguments; + readonly IReadOnlyList methodTypeArguments; + + /// + /// Creates a new type parameter substitution. + /// + /// + /// The type arguments to substitute for class type parameters. + /// Pass null to keep class type parameters unmodified. + /// + /// + /// The type arguments to substitute for method type parameters. + /// Pass null to keep method type parameters unmodified. + /// + public TypeParameterSubstitution(IReadOnlyList classTypeArguments, IReadOnlyList methodTypeArguments) + { + this.classTypeArguments = classTypeArguments; + this.methodTypeArguments = methodTypeArguments; + } + + /// + /// Gets the list of class type arguments. + /// Returns null if this substitution keeps class type parameters unmodified. + /// + public IReadOnlyList ClassTypeArguments { + get { return classTypeArguments; } + } + + /// + /// Gets the list of method type arguments. + /// Returns null if this substitution keeps method type parameters unmodified. + /// + public IReadOnlyList MethodTypeArguments { + get { return methodTypeArguments; } + } + + #region Compose + /// + /// Computes a single TypeParameterSubstitution so that for all types t: + /// t.AcceptVisitor(Compose(g, f)) equals t.AcceptVisitor(f).AcceptVisitor(g) + /// + /// If you consider type parameter substitution to be a function, this is function composition. + public static TypeParameterSubstitution Compose(TypeParameterSubstitution g, TypeParameterSubstitution f) + { + if (g == null) + return f; + if (f == null || (f.classTypeArguments == null && f.methodTypeArguments == null)) + return g; + // The composition is a copy of 'f', with 'g' applied on the array elements. + // If 'f' has a null list (keeps type parameters unmodified), we have to treat it as + // the identity function, and thus use the list from 'g'. + var classTypeArguments = f.classTypeArguments != null ? GetComposedTypeArguments(f.classTypeArguments, g) : g.classTypeArguments; + var methodTypeArguments = f.methodTypeArguments != null ? GetComposedTypeArguments(f.methodTypeArguments, g) : g.methodTypeArguments; + return new TypeParameterSubstitution(classTypeArguments, methodTypeArguments); + } + + static IReadOnlyList GetComposedTypeArguments(IReadOnlyList input, TypeParameterSubstitution substitution) + { + var result = new IType[input.Count]; + for (var i = 0; i < result.Length; i++) + { + result[i] = input[i].AcceptVisitor(substitution); + } + return result; + } + #endregion + + #region Equals and GetHashCode implementation + public bool Equals(TypeParameterSubstitution other, TypeVisitor normalization) + { + if (other == null) + return false; + return TypeListEquals(classTypeArguments, other.classTypeArguments, normalization) + && TypeListEquals(methodTypeArguments, other.methodTypeArguments, normalization); + } + + public override bool Equals(object obj) + { + var other = obj as TypeParameterSubstitution; + if (other == null) + return false; + return TypeListEquals(classTypeArguments, other.classTypeArguments) + && TypeListEquals(methodTypeArguments, other.methodTypeArguments); + } + + public override int GetHashCode() + { + unchecked + { + return 1124131 * TypeListHashCode(classTypeArguments) + 1821779 * TypeListHashCode(methodTypeArguments); + } + } + + static bool TypeListEquals(IReadOnlyList a, IReadOnlyList b) + { + if (a == b) + return true; + if (a == null || b == null) + return false; + if (a.Count != b.Count) + return false; + for (var i = 0; i < a.Count; i++) + { + if (!a[i].Equals(b[i])) + return false; + } + return true; + } + + static bool TypeListEquals(IReadOnlyList a, IReadOnlyList b, TypeVisitor normalization) + { + if (a == b) + return true; + if (a == null || b == null) + return false; + if (a.Count != b.Count) + return false; + for (var i = 0; i < a.Count; i++) + { + var an = a[i].AcceptVisitor(normalization); + var bn = b[i].AcceptVisitor(normalization); + if (!an.Equals(bn)) + return false; + } + return true; + } + + static int TypeListHashCode(IReadOnlyList obj) + { + if (obj == null) + return 0; + unchecked + { + var hashCode = 1; + foreach (var element in obj) + { + hashCode *= 27; + hashCode += element.GetHashCode(); + } + return hashCode; + } + } + #endregion + + public override IType VisitTypeParameter(ITypeParameter type) + { + var index = type.Index; + if (classTypeArguments != null && type.OwnerType == SymbolKind.TypeDefinition) + { + if (index >= 0 && index < classTypeArguments.Count) + return classTypeArguments[index]; + else + return SpecialType.UnknownType; + } + else if (methodTypeArguments != null && type.OwnerType == SymbolKind.Method) + { + if (index >= 0 && index < methodTypeArguments.Count) + return methodTypeArguments[index]; + else + return SpecialType.UnknownType; + } + else + { + return base.VisitTypeParameter(type); + } + } + + public override IType VisitNullabilityAnnotatedType(NullabilityAnnotatedType type) + { + if (type is NullabilityAnnotatedTypeParameter tp) + { + if (tp.Nullability == Nullability.Nullable) + { + return VisitTypeParameter(tp).ChangeNullability(Nullability.Nullable); + } + else + { + // T! substituted with T=oblivious string should result in oblivious string + return VisitTypeParameter(tp); + } + } + else + { + return base.VisitNullabilityAnnotatedType(type); + } + } + + public override string ToString() + { + var b = new StringBuilder(); + b.Append('['); + var first = true; + if (classTypeArguments != null) + { + for (var i = 0; i < classTypeArguments.Count; i++) + { + if (first) + first = false; + else + b.Append(", "); + b.Append('`'); + b.Append(i); + b.Append(" -> "); + b.Append(classTypeArguments[i].ReflectionName); + } + if (classTypeArguments.Count == 0) + { + if (first) + first = false; + else + b.Append(", "); + b.Append("[]"); + } + } + if (methodTypeArguments != null) + { + for (var i = 0; i < methodTypeArguments.Count; i++) + { + if (first) + first = false; + else + b.Append(", "); + b.Append("``"); + b.Append(i); + b.Append(" -> "); + b.Append(methodTypeArguments[i].ReflectionName); + } + if (methodTypeArguments.Count == 0) + { + if (first) + first = false; + else + b.Append(", "); + b.Append("[]"); + } + } + b.Append(']'); + return b.ToString(); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/TypeProvider.cs b/src/ICSharpCode.Decompiler/TypeSystem/TypeProvider.cs new file mode 100644 index 0000000..5a49c30 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/TypeProvider.cs @@ -0,0 +1,191 @@ +// Copyright (c) 2018 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Immutable; +using System.Reflection.Metadata.Ecma335; + +using ICSharpCode.Decompiler.Metadata; +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +using SRM = System.Reflection.Metadata; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Allows decoding signatures using decompiler types. + /// + sealed class TypeProvider : ICompilationProvider, + SRM.ISignatureTypeProvider, + SRM.ICustomAttributeTypeProvider + { + readonly MetadataModule module; + readonly ICompilation compilation; + + public TypeProvider(MetadataModule module) + { + this.module = module; + this.compilation = module.Compilation; + } + + public TypeProvider(ICompilation compilation) + { + this.compilation = compilation; + } + + public ICompilation Compilation => compilation; + + public IType GetArrayType(IType elementType, SRM.ArrayShape shape) + { + return new ArrayType(compilation, elementType, shape.Rank); + } + + public IType GetByReferenceType(IType elementType) + { + return new ByReferenceType(elementType); + } + + public IType GetFunctionPointerType(SRM.MethodSignature signature) + { + if (signature.Header.IsInstance) + { + // pointers to member functions are not supported even in C# 9 + return compilation.FindType(KnownTypeCode.IntPtr); + } + return FunctionPointerType.FromSignature(signature, module); + } + + public IType GetGenericInstantiation(IType genericType, ImmutableArray typeArguments) + { + return new ParameterizedType(genericType, typeArguments); + } + + public IType GetGenericMethodParameter(GenericContext genericContext, int index) + { + return genericContext.GetMethodTypeParameter(index); + } + + public IType GetGenericTypeParameter(GenericContext genericContext, int index) + { + return genericContext.GetClassTypeParameter(index); + } + + public IType GetModifiedType(IType modifier, IType unmodifiedType, bool isRequired) + { + return new ModifiedType(modifier, unmodifiedType, isRequired); + } + + public IType GetPinnedType(IType elementType) + { + return new PinnedType(elementType); + } + + public IType GetPointerType(IType elementType) + { + return new PointerType(elementType); + } + + public IType GetPrimitiveType(SRM.PrimitiveTypeCode typeCode) + { + return compilation.FindType(typeCode.ToKnownTypeCode()); + } + + public IType GetSystemType() + { + return compilation.FindType(KnownTypeCode.Type); + } + + public IType GetSZArrayType(IType elementType) + { + return new ArrayType(compilation, elementType); + } + + bool? IsReferenceType(SRM.MetadataReader reader, SRM.EntityHandle handle, byte rawTypeKind) + { + switch (reader.ResolveSignatureTypeKind(handle, rawTypeKind)) + { + case SRM.SignatureTypeKind.ValueType: + return false; + case SRM.SignatureTypeKind.Class: + return true; + default: + return null; + } + } + + public IType GetTypeFromDefinition(SRM.MetadataReader reader, SRM.TypeDefinitionHandle handle, byte rawTypeKind) + { + var td = module?.GetDefinition(handle); + if (td != null) + return td; + var isReferenceType = IsReferenceType(reader, handle, rawTypeKind); + return new UnknownType(handle.GetFullTypeName(reader), isReferenceType); + } + + public IType GetTypeFromReference(SRM.MetadataReader reader, SRM.TypeReferenceHandle handle, byte rawTypeKind) + { + var resolvedModule = module.GetDeclaringModule(handle); + var fullTypeName = handle.GetFullTypeName(reader); + IType type; + if (resolvedModule != null) + { + type = resolvedModule.GetTypeDefinition(fullTypeName); + } + else + { + type = GetClassTypeReference.ResolveInAllAssemblies(compilation, in fullTypeName); + } + return type ?? new UnknownType(fullTypeName, IsReferenceType(reader, handle, rawTypeKind)); + } + + public IType GetTypeFromSerializedName(string name) + { + if (name == null) + { + return null; + } + try + { + return ReflectionHelper.ParseReflectionName(name) + .Resolve(module != null ? new SimpleTypeResolveContext(module) : new SimpleTypeResolveContext(compilation)); + } + catch (ReflectionNameParseException ex) + { + throw new BadImageFormatException($"Invalid type name: \"{name}\": {ex.Message}"); + } + } + + public IType GetTypeFromSpecification(SRM.MetadataReader reader, GenericContext genericContext, SRM.TypeSpecificationHandle handle, byte rawTypeKind) + { + return reader.GetTypeSpecification(handle).DecodeSignature(this, genericContext); + } + + public SRM.PrimitiveTypeCode GetUnderlyingEnumType(IType type) + { + var def = type.GetEnumUnderlyingType().GetDefinition(); + if (def == null) + throw new EnumUnderlyingTypeResolveException(); + return def.KnownTypeCode.ToPrimitiveTypeCode(); + } + + public bool IsSystemType(IType type) + { + return type.IsKnownType(KnownTypeCode.Type); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/TypeSystemExtensions.cs b/src/ICSharpCode.Decompiler/TypeSystem/TypeSystemExtensions.cs new file mode 100644 index 0000000..494efff --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/TypeSystemExtensions.cs @@ -0,0 +1,620 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Linq; + +using ICSharpCode.Decompiler.Metadata; +using ICSharpCode.Decompiler.Semantics; +using ICSharpCode.Decompiler.TypeSystem.Implementation; +using ICSharpCode.Decompiler.Util; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Contains extension methods for the type system. + /// + public static class TypeSystemExtensions + { + #region GetAllBaseTypes + /// + /// Gets all base types. + /// + /// This is the reflexive and transitive closure of . + /// Note that this method does not return all supertypes - doing so is impossible due to contravariance + /// (and undesirable for covariance as the list could become very large). + /// + /// The output is ordered so that base types occur before derived types. + /// + public static IEnumerable GetAllBaseTypes(this IType type) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + var collector = new BaseTypeCollector(); + collector.CollectBaseTypes(type); + return collector; + } + + /// + /// Gets all non-interface base types. + /// + /// + /// When is an interface, this method will also return base interfaces (return same output as GetAllBaseTypes()). + /// + /// The output is ordered so that base types occur before derived types. + /// + public static IEnumerable GetNonInterfaceBaseTypes(this IType type) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + var collector = new BaseTypeCollector(); + collector.SkipImplementedInterfaces = true; + collector.CollectBaseTypes(type); + return collector; + } + #endregion + + #region GetAllBaseTypeDefinitions + /// + /// Gets all base type definitions. + /// The output is ordered so that base types occur before derived types. + /// + /// + /// This is equivalent to type.GetAllBaseTypes().Select(t => t.GetDefinition()).Where(d => d != null).Distinct(). + /// + public static IEnumerable GetAllBaseTypeDefinitions(this IType type) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + + return type.GetAllBaseTypes().Select(t => t.GetDefinition()).Where(d => d != null).Distinct(); + } + + /// + /// Gets whether this type definition is derived from the base type definition. + /// + public static bool IsDerivedFrom(this ITypeDefinition type, ITypeDefinition baseType) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + if (baseType == null) + return false; + if (type.Compilation != baseType.Compilation) + { + throw new InvalidOperationException("Both arguments to IsDerivedFrom() must be from the same compilation."); + } + return type.GetAllBaseTypeDefinitions().Contains(baseType); + } + + /// + /// Gets whether this type definition is derived from a given known type. + /// + public static bool IsDerivedFrom(this ITypeDefinition type, KnownTypeCode baseType) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + if (baseType == KnownTypeCode.None) + return false; + return IsDerivedFrom(type, type.Compilation.FindType(baseType).GetDefinition()); + } + #endregion + + #region GetDeclaringTypeDefinitionsOrThis + /// + /// Returns all declaring type definitions of this type definition. + /// The output is ordered so that inner types occur before outer types. + /// + public static IEnumerable GetDeclaringTypeDefinitions(this ITypeDefinition definition) + { + if (definition == null) + { + throw new ArgumentNullException(nameof(definition)); + } + + while (definition != null) + { + yield return definition; + definition = definition.DeclaringTypeDefinition; + } + } + #endregion + + #region IsOpen / IsUnbound / IsKnownType + sealed class TypeClassificationVisitor : TypeVisitor + { + internal bool isOpen; + internal IEntity typeParameterOwner; + int typeParameterOwnerNestingLevel; + + public override IType VisitTypeParameter(ITypeParameter type) + { + isOpen = true; + // If both classes and methods, or different classes (nested types) + // are involved, find the most specific one + var newNestingLevel = GetNestingLevel(type.Owner); + if (newNestingLevel > typeParameterOwnerNestingLevel) + { + typeParameterOwner = type.Owner; + typeParameterOwnerNestingLevel = newNestingLevel; + } + return base.VisitTypeParameter(type); + } + + static int GetNestingLevel(IEntity entity) + { + var level = 0; + while (entity != null) + { + level++; + entity = entity.DeclaringTypeDefinition; + } + return level; + } + } + + /// + /// Gets whether the type is an open type (contains type parameters). + /// + /// + /// + /// class X<T> { + /// List<T> open; + /// X<X<T[]>> open; + /// X<string> closed; + /// int closed; + /// } + /// + /// + public static bool IsOpen(this IType type) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + var v = new TypeClassificationVisitor(); + type.AcceptVisitor(v); + return v.isOpen; + } + + /// + /// Gets the entity that owns the type parameters occurring in the specified type. + /// If both class and method type parameters are present, the method is returned. + /// Returns null if the specified type is closed. + /// + /// + static IEntity GetTypeParameterOwner(IType type) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + var v = new TypeClassificationVisitor(); + type.AcceptVisitor(v); + return v.typeParameterOwner; + } + + /// + /// Gets whether the type is unbound (is a generic type, but no type arguments were provided). + /// + /// + /// In "typeof(List<Dictionary<,>>)", only the Dictionary is unbound, the List is considered + /// bound despite containing an unbound type. + /// This method returns false for partially parameterized types (Dictionary<string, >). + /// + public static bool IsUnbound(this IType type) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + return (type is ITypeDefinition || type is UnknownType) && type.TypeParameterCount > 0; + } + + /// + /// Gets whether the type is the specified known type. + /// For generic known types, this returns true for any parameterization of the type (and also for the definition itself). + /// + public static bool IsKnownType(this IType type, KnownTypeCode knownType) + { + var def = type.GetDefinition(); + return def != null && def.KnownTypeCode == knownType; + } + + /// + /// Gets whether the type is the specified known type. + /// For generic known types, this returns true for any parameterization of the type (and also for the definition itself). + /// + internal static bool IsKnownType(this IType type, KnownAttribute knownType) + { + var def = type.GetDefinition(); + return def != null && def.FullTypeName.IsKnownType(knownType); + } + + public static bool IsKnownType(this FullTypeName typeName, KnownTypeCode knownType) + { + return typeName == KnownTypeReference.Get(knownType).TypeName; + } + + public static bool IsKnownType(this TopLevelTypeName typeName, KnownTypeCode knownType) + { + return typeName == KnownTypeReference.Get(knownType).TypeName; + } + + internal static bool IsKnownType(this FullTypeName typeName, KnownAttribute knownType) + { + return typeName == knownType.GetTypeName(); + } + + internal static bool IsKnownType(this TopLevelTypeName typeName, KnownAttribute knownType) + { + return typeName == knownType.GetTypeName(); + } + #endregion + + #region GetDelegateInvokeMethod + /// + /// Gets the invoke method for a delegate type. + /// + /// + /// Returns null if the type is not a delegate type; or if the invoke method could not be found. + /// + public static IMethod GetDelegateInvokeMethod(this IType type) + { + if (type == null) + throw new ArgumentNullException(nameof(type)); + if (type.Kind == TypeKind.Delegate) + return type.GetMethods(m => m.Name == "Invoke", GetMemberOptions.IgnoreInheritedMembers).FirstOrDefault(); + else + return null; + } + #endregion + + public static IType SkipModifiers(this IType ty) + { + while (ty is ModifiedType mt) + { + ty = mt.ElementType; + } + return ty; + } + + public static bool HasReadonlyModifier(this IMethod accessor) + { + return accessor.ThisIsRefReadOnly && accessor.DeclaringTypeDefinition?.IsReadOnly == false; + } + + public static bool IsAnyPointer(this TypeKind typeKind) + { + return typeKind switch + { + TypeKind.Pointer => true, + TypeKind.FunctionPointer => true, + _ => false + }; + } + + #region GetType/Member + /// + /// Gets all type definitions in the compilation. + /// This may include types from referenced assemblies that are not accessible in the main assembly. + /// + public static IEnumerable GetAllTypeDefinitions(this ICompilation compilation) + { + return compilation.Modules.SelectMany(a => a.TypeDefinitions); + } + + /// + /// Gets all top level type definitions in the compilation. + /// This may include types from referenced assemblies that are not accessible in the main assembly. + /// + public static IEnumerable GetTopLevelTypeDefinitions(this ICompilation compilation) + { + return compilation.Modules.SelectMany(a => a.TopLevelTypeDefinitions); + } + #endregion + + #region Resolve on collections + public static IReadOnlyList Resolve(this IList typeReferences, ITypeResolveContext context) + { + if (typeReferences == null) + throw new ArgumentNullException(nameof(typeReferences)); + if (typeReferences.Count == 0) + return EmptyList.Instance; + else + return new ProjectedList(context, typeReferences, (c, t) => t.Resolve(c)); + } + + // There is intentionally no Resolve() overload for IList: the resulting IList would + // contains nulls when there are resolve errors. + #endregion + + #region IAssembly.GetTypeDefinition() + /// + /// Retrieves the specified type in this compilation. + /// Returns an if the type cannot be found in this compilation. + /// + /// + /// There can be multiple types with the same full name in a compilation, as a + /// full type name is only unique per assembly. + /// If there are multiple possible matches, this method will return just one of them. + /// When possible, use instead to + /// retrieve a type from a specific assembly. + /// + public static IType FindType(this ICompilation compilation, FullTypeName fullTypeName) + { + if (compilation == null) + throw new ArgumentNullException(nameof(compilation)); + foreach (var asm in compilation.Modules) + { + var def = asm.GetTypeDefinition(fullTypeName); + if (def != null) + return def; + } + return new UnknownType(fullTypeName); + } + + /// + /// Gets the type definition for the specified unresolved type. + /// Returns null if the unresolved type does not belong to this assembly. + /// + public static ITypeDefinition GetTypeDefinition(this IModule module, FullTypeName fullTypeName) + { + if (module == null) + throw new ArgumentNullException("assembly"); + var topLevelTypeName = fullTypeName.TopLevelTypeName; + var typeDef = module.GetTypeDefinition(topLevelTypeName); + if (typeDef == null) + return null; + var typeParameterCount = topLevelTypeName.TypeParameterCount; + for (var i = 0; i < fullTypeName.NestingLevel; i++) + { + var name = fullTypeName.GetNestedTypeName(i); + typeParameterCount += fullTypeName.GetNestedTypeAdditionalTypeParameterCount(i); + typeDef = FindNestedType(typeDef, name, typeParameterCount); + if (typeDef == null) + break; + } + return typeDef; + } + + static ITypeDefinition FindNestedType(ITypeDefinition typeDef, string name, int typeParameterCount) + { + foreach (var nestedType in typeDef.NestedTypes) + { + if (nestedType.Name == name && nestedType.TypeParameterCount == typeParameterCount) + return nestedType; + } + return null; + } + #endregion + + #region IEntity.GetAttribute + /// + /// Gets whether the entity has an attribute of the specified attribute type (or derived attribute types). + /// + /// The entity on which the attributes are declared. + /// The attribute type to look for. + /// + /// Specifies whether attributes inherited from base classes and base members + /// (if the given in an override) + /// should be returned. + /// + public static bool HasAttribute(this IEntity entity, KnownAttribute attributeType, bool inherit = false) + { + return GetAttribute(entity, attributeType, inherit) != null; + } + + /// + /// Gets the attribute of the specified attribute type (or derived attribute types). + /// + /// The entity on which the attributes are declared. + /// The attribute type to look for. + /// + /// Specifies whether attributes inherited from base classes and base members + /// (if the given in an override) + /// should be returned. + /// + /// + /// Returns the attribute that was found; or null if none was found. + /// If inherit is true, an from the entity itself will be returned if possible; + /// and the base entity will only be searched if none exists. + /// + public static IAttribute GetAttribute(this IEntity entity, KnownAttribute attributeType, bool inherit = false) + { + return GetAttributes(entity, inherit).FirstOrDefault(a => a.AttributeType.IsKnownType(attributeType)); + } + + /// + /// Gets the attributes on the entity. + /// + /// The entity on which the attributes are declared. + /// + /// Specifies whether attributes inherited from base classes and base members + /// (if the given in an override) + /// should be returned. + /// + /// + /// Returns the list of attributes that were found. + /// If inherit is true, attributes from the entity itself are returned first; + /// followed by attributes inherited from the base entity. + /// + public static IEnumerable GetAttributes(this IEntity entity, bool inherit) + { + if (inherit) + { + if (entity is ITypeDefinition td) + { + return InheritanceHelper.GetAttributes(td); + } + else if (entity is IMember m) + { + return InheritanceHelper.GetAttributes(m); + } + else + { + throw new NotSupportedException("Unknown entity type"); + } + } + else + { + return entity.GetAttributes(); + } + } + #endregion + + #region IParameter.GetAttribute + /// + /// Gets whether the parameter has an attribute of the specified attribute type (or derived attribute types). + /// + /// The parameter on which the attributes are declared. + /// The attribute type to look for. + public static bool HasAttribute(this IParameter parameter, KnownAttribute attributeType) + { + return GetAttribute(parameter, attributeType) != null; + } + + /// + /// Gets the attribute of the specified attribute type (or derived attribute types). + /// + /// The parameter on which the attributes are declared. + /// The attribute type to look for. + /// + /// Returns the attribute that was found; or null if none was found. + /// + public static IAttribute GetAttribute(this IParameter parameter, KnownAttribute attributeType) + { + return parameter.GetAttributes().FirstOrDefault(a => a.AttributeType.IsKnownType(attributeType)); + } + #endregion + + #region IAssembly.GetTypeDefinition(string,string,int) + /// + /// Gets the type definition for a top-level type. + /// + /// This method uses ordinal name comparison, not the compilation's name comparer. + public static ITypeDefinition GetTypeDefinition(this IModule module, string namespaceName, string name, int typeParameterCount = 0) + { + if (module == null) + throw new ArgumentNullException("assembly"); + return module.GetTypeDefinition(new TopLevelTypeName(namespaceName, name, typeParameterCount)); + } + #endregion + + #region ResolveResult + public static ISymbol GetSymbol(this ResolveResult rr) + { + if (rr is LocalResolveResult) + { + return ((LocalResolveResult)rr).Variable; + } + else if (rr is MemberResolveResult) + { + return ((MemberResolveResult)rr).Member; + } + else if (rr is TypeResolveResult) + { + return ((TypeResolveResult)rr).Type.GetDefinition(); + } + else if (rr is ConversionResolveResult) + { + return ((ConversionResolveResult)rr).Input.GetSymbol(); + } + + return null; + } + #endregion + + public static IType GetElementTypeFromIEnumerable(this IType collectionType, ICompilation compilation, bool allowIEnumerator, out bool? isGeneric) + { + var foundNonGenericIEnumerable = false; + foreach (var baseType in collectionType.GetAllBaseTypes()) + { + var baseTypeDef = baseType.GetDefinition(); + if (baseTypeDef != null) + { + var typeCode = baseTypeDef.KnownTypeCode; + if (typeCode == KnownTypeCode.IEnumerableOfT || (allowIEnumerator && typeCode == KnownTypeCode.IEnumeratorOfT)) + { + var pt = baseType as ParameterizedType; + if (pt != null) + { + isGeneric = true; + return pt.GetTypeArgument(0); + } + } + if (typeCode == KnownTypeCode.IEnumerable || (allowIEnumerator && typeCode == KnownTypeCode.IEnumerator)) + foundNonGenericIEnumerable = true; + } + } + // System.Collections.IEnumerable found in type hierarchy -> Object is element type. + if (foundNonGenericIEnumerable) + { + isGeneric = false; + return compilation.FindType(KnownTypeCode.Object); + } + isGeneric = null; + return SpecialType.UnknownType; + } + + public static bool FullNameIs(this IMember member, string type, string name) + { + return member.Name == name && member.DeclaringType?.FullName == type; + } + + public static KnownAttribute IsBuiltinAttribute(this ITypeDefinition type) + { + return KnownAttributes.IsKnownAttributeType(type); + } + + public static IType WithoutNullability(this IType type) + { + return type.ChangeNullability(Nullability.Oblivious); + } + + public static bool IsDirectImportOf(this ITypeDefinition type, IModule module) + { + var moduleReference = type.ParentModule; + foreach (var asmRef in module.PEFile.AssemblyReferences) + { + if (asmRef.FullName == moduleReference.FullAssemblyName) + return true; + if (asmRef.Name == "netstandard" && asmRef.GetPublicKeyToken() != null) + { + var referencedModule = module.Compilation.FindModuleByReference(asmRef); + if (referencedModule != null && !referencedModule.PEFile.GetTypeForwarder(type.FullTypeName).IsNil) + return true; + } + } + return false; + } + + public static IModule FindModuleByReference(this ICompilation compilation, IAssemblyReference assemblyName) + { + foreach (var module in compilation.Modules) + { + if (string.Equals(module.FullAssemblyName, assemblyName.FullName, StringComparison.OrdinalIgnoreCase)) + { + return module; + } + } + foreach (var module in compilation.Modules) + { + if (string.Equals(module.Name, assemblyName.Name, StringComparison.OrdinalIgnoreCase)) + { + return module; + } + } + return null; + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/TypeUtils.cs b/src/ICSharpCode.Decompiler/TypeSystem/TypeUtils.cs new file mode 100644 index 0000000..5115143 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/TypeUtils.cs @@ -0,0 +1,525 @@ +// Copyright (c) 2015 Siegfried Pammer +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using ICSharpCode.Decompiler.IL; +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + public static class TypeUtils + { + public const int NativeIntSize = 6; // between 4 (Int32) and 8 (Int64) + + /// + /// Gets the size (in bytes) of the input type. + /// Returns NativeIntSize for pointer-sized types. + /// Returns 0 for structs and other types of unknown size. + /// + public static int GetSize(this IType type) + { + switch (type.Kind) + { + case TypeKind.Pointer: + case TypeKind.ByReference: + case TypeKind.Class: + case TypeKind.NInt: + case TypeKind.NUInt: + return NativeIntSize; + case TypeKind.Enum: + type = type.GetEnumUnderlyingType(); + break; + case TypeKind.ModOpt: + case TypeKind.ModReq: + return type.SkipModifiers().GetSize(); + } + + var typeDef = type.GetDefinition(); + if (typeDef == null) + return 0; + switch (typeDef.KnownTypeCode) + { + case KnownTypeCode.Boolean: + case KnownTypeCode.SByte: + case KnownTypeCode.Byte: + return 1; + case KnownTypeCode.Char: + case KnownTypeCode.Int16: + case KnownTypeCode.UInt16: + return 2; + case KnownTypeCode.Int32: + case KnownTypeCode.UInt32: + case KnownTypeCode.Single: + return 4; + case KnownTypeCode.IntPtr: + case KnownTypeCode.UIntPtr: + return NativeIntSize; + case KnownTypeCode.Int64: + case KnownTypeCode.UInt64: + case KnownTypeCode.Double: + return 8; + } + return 0; + } + + /// + /// Gets the size of the input stack type. + /// + /// + /// * 4 for I4, + /// * 8 for I8, + /// * NativeIntSize for I and Ref, + /// * 0 otherwise (O, F, Void, Unknown). + /// + public static int GetSize(this StackType type) + { + switch (type) + { + case StackType.I4: + return 4; + case StackType.I8: + return 8; + case StackType.I: + case StackType.Ref: + return NativeIntSize; + default: + return 0; + } + } + + public static IType GetLargerType(IType type1, IType type2) + { + return GetSize(type1) >= GetSize(type2) ? type1 : type2; + } + + /// + /// Gets whether the type is a small integer type. + /// Small integer types are: + /// * bool, sbyte, byte, char, short, ushort + /// * any enums that have a small integer type as underlying type + /// + public static bool IsSmallIntegerType(this IType type) + { + var size = GetSize(type); + return size > 0 && size < 4; + } + + /// + /// Gets whether the type is a C# small integer type: byte, sbyte, short or ushort. + /// + /// Unlike the ILAst, C# does not consider bool, char or enums to be small integers. + /// + public static bool IsCSharpSmallIntegerType(this IType type) + { + switch (type.GetDefinition()?.KnownTypeCode) + { + case KnownTypeCode.Byte: + case KnownTypeCode.SByte: + case KnownTypeCode.Int16: + case KnownTypeCode.UInt16: + return true; + default: + return false; + } + } + + /// + /// Gets whether the type is a C# 9 native integer type: nint or nuint. + /// + /// Returns false for (U)IntPtr. + /// + public static bool IsCSharpNativeIntegerType(this IType type) + { + switch (type.Kind) + { + case TypeKind.NInt: + case TypeKind.NUInt: + return true; + default: + return false; + } + } + + /// + /// Gets whether the type is a C# primitive integer type: byte, sbyte, short, ushort, int, uint, long and ulong. + /// + /// Unlike the ILAst, C# does not consider bool, enums, pointers or IntPtr to be integers. + /// + public static bool IsCSharpPrimitiveIntegerType(this IType type) + { + switch (type.GetDefinition()?.KnownTypeCode) + { + case KnownTypeCode.Byte: + case KnownTypeCode.SByte: + case KnownTypeCode.Int16: + case KnownTypeCode.UInt16: + case KnownTypeCode.Int32: + case KnownTypeCode.UInt32: + case KnownTypeCode.Int64: + case KnownTypeCode.UInt64: + return true; + default: + return false; + } + } + + /// + /// Gets whether the type is an IL integer type. + /// Returns true for I4, I, or I8. + /// + public static bool IsIntegerType(this StackType type) + { + switch (type) + { + case StackType.I4: + case StackType.I: + case StackType.I8: + return true; + default: + return false; + } + } + + /// + /// Gets whether the type is an IL floating point type. + /// Returns true for F4 or F8. + /// + public static bool IsFloatType(this StackType type) + { + switch (type) + { + case StackType.F4: + case StackType.F8: + return true; + default: + return false; + } + } + + /// + /// Gets whether reading/writing an element of accessType from the pointer + /// is equivalent to reading/writing an element of the pointer's element type. + /// + /// + /// The access semantics may sligthly differ on read accesses of small integer types, + /// due to zero extension vs. sign extension when the signs differ. + /// + public static bool IsCompatiblePointerTypeForMemoryAccess(IType pointerType, IType accessType) + { + IType memoryType; + if (pointerType is PointerType || pointerType is ByReferenceType) + memoryType = ((TypeWithElementType)pointerType).ElementType; + else + return false; + return IsCompatibleTypeForMemoryAccess(memoryType, accessType); + } + + /// + /// Gets whether reading/writing an element of accessType from the pointer + /// is equivalent to reading/writing an element of the memoryType. + /// + /// + /// The access semantics may sligthly differ on read accesses of small integer types, + /// due to zero extension vs. sign extension when the signs differ. + /// + public static bool IsCompatibleTypeForMemoryAccess(IType memoryType, IType accessType) + { + memoryType = memoryType.AcceptVisitor(NormalizeTypeVisitor.TypeErasure); + accessType = accessType.AcceptVisitor(NormalizeTypeVisitor.TypeErasure); + if (memoryType.Equals(accessType)) + return true; + // If the types are not equal, the access still might produce equal results in some cases: + // 1) Both types are reference types + if (memoryType.IsReferenceType == true && accessType.IsReferenceType == true) + return true; + // 2) Both types are integer types of equal size + var memoryStackType = memoryType.GetStackType(); + var accessStackType = accessType.GetStackType(); + if (memoryStackType == accessStackType && memoryStackType.IsIntegerType() && GetSize(memoryType) == GetSize(accessType)) + return true; + // 3) Any of the types is unknown: we assume they are compatible. + return memoryType.Kind == TypeKind.Unknown || accessType.Kind == TypeKind.Unknown; + } + + /// + /// Gets the stack type corresponding to this type. + /// + public static StackType GetStackType(this IType type) + { + switch (type.Kind) + { + case TypeKind.Unknown: + if (type.IsReferenceType == true) + { + return StackType.O; + } + return StackType.Unknown; + case TypeKind.ByReference: + return StackType.Ref; + case TypeKind.Pointer: + case TypeKind.NInt: + case TypeKind.NUInt: + case TypeKind.FunctionPointer: + return StackType.I; + case TypeKind.TypeParameter: + // Type parameters are always considered StackType.O, even + // though they might be instantiated with primitive types. + return StackType.O; + case TypeKind.ModOpt: + case TypeKind.ModReq: + return type.SkipModifiers().GetStackType(); + } + ITypeDefinition typeDef = type.GetEnumUnderlyingType().GetDefinition(); + if (typeDef == null) + return StackType.O; + switch (typeDef.KnownTypeCode) + { + case KnownTypeCode.Boolean: + case KnownTypeCode.Char: + case KnownTypeCode.SByte: + case KnownTypeCode.Byte: + case KnownTypeCode.Int16: + case KnownTypeCode.UInt16: + case KnownTypeCode.Int32: + case KnownTypeCode.UInt32: + return StackType.I4; + case KnownTypeCode.Int64: + case KnownTypeCode.UInt64: + return StackType.I8; + case KnownTypeCode.Single: + return StackType.F4; + case KnownTypeCode.Double: + return StackType.F8; + case KnownTypeCode.Void: + return StackType.Void; + case KnownTypeCode.IntPtr: + case KnownTypeCode.UIntPtr: + return StackType.I; + default: + return StackType.O; + } + } + + /// + /// If type is an enumeration type, returns the underlying type. + /// Otherwise, returns type unmodified. + /// + public static IType GetEnumUnderlyingType(this IType type) + { + type = type.SkipModifiers(); + return (type.Kind == TypeKind.Enum) ? type.GetDefinition().EnumUnderlyingType : type; + } + + /// + /// Gets the sign of the input type. + /// + /// + /// Integer types (including IntPtr/UIntPtr) return the sign as expected. + /// Floating point types and decimal are considered to be signed. + /// char, bool and pointer types (e.g. void*) are unsigned. + /// Enums have a sign based on their underlying type. + /// All other types return Sign.None. + /// + public static Sign GetSign(this IType type) + { + type = type.SkipModifiers(); + switch (type.Kind) + { + case TypeKind.Pointer: + case TypeKind.NUInt: + case TypeKind.FunctionPointer: + return Sign.Unsigned; + case TypeKind.NInt: + return Sign.Signed; + } + var typeDef = type.GetEnumUnderlyingType().GetDefinition(); + if (typeDef == null) + return Sign.None; + switch (typeDef.KnownTypeCode) + { + case KnownTypeCode.SByte: + case KnownTypeCode.Int16: + case KnownTypeCode.Int32: + case KnownTypeCode.Int64: + case KnownTypeCode.IntPtr: + case KnownTypeCode.Single: + case KnownTypeCode.Double: + case KnownTypeCode.Decimal: + return Sign.Signed; + case KnownTypeCode.UIntPtr: + case KnownTypeCode.Char: + case KnownTypeCode.Boolean: + case KnownTypeCode.Byte: + case KnownTypeCode.UInt16: + case KnownTypeCode.UInt32: + case KnownTypeCode.UInt64: + return Sign.Unsigned; + default: + return Sign.None; + } + } + + /// + /// Maps the KnownTypeCode values to the corresponding PrimitiveTypes. + /// + public static PrimitiveType ToPrimitiveType(this KnownTypeCode knownTypeCode) + { + switch (knownTypeCode) + { + case KnownTypeCode.SByte: + return PrimitiveType.I1; + case KnownTypeCode.Int16: + return PrimitiveType.I2; + case KnownTypeCode.Int32: + return PrimitiveType.I4; + case KnownTypeCode.Int64: + return PrimitiveType.I8; + case KnownTypeCode.Single: + return PrimitiveType.R4; + case KnownTypeCode.Double: + return PrimitiveType.R8; + case KnownTypeCode.Byte: + return PrimitiveType.U1; + case KnownTypeCode.UInt16: + case KnownTypeCode.Char: + return PrimitiveType.U2; + case KnownTypeCode.UInt32: + return PrimitiveType.U4; + case KnownTypeCode.UInt64: + return PrimitiveType.U8; + case KnownTypeCode.IntPtr: + return PrimitiveType.I; + case KnownTypeCode.UIntPtr: + return PrimitiveType.U; + default: + return PrimitiveType.None; + } + } + + /// + /// Maps the KnownTypeCode values to the corresponding PrimitiveTypes. + /// + public static PrimitiveType ToPrimitiveType(this IType type) + { + type = type.SkipModifiers(); + switch (type.Kind) + { + case TypeKind.Unknown: + return PrimitiveType.Unknown; + case TypeKind.ByReference: + return PrimitiveType.Ref; + case TypeKind.NInt: + case TypeKind.FunctionPointer: + return PrimitiveType.I; + case TypeKind.NUInt: + return PrimitiveType.U; + } + var def = type.GetEnumUnderlyingType().GetDefinition(); + return def != null ? def.KnownTypeCode.ToPrimitiveType() : PrimitiveType.None; + } + + /// + /// Maps the PrimitiveType values to the corresponding KnownTypeCodes. + /// + public static KnownTypeCode ToKnownTypeCode(this PrimitiveType primitiveType) + { + switch (primitiveType) + { + case PrimitiveType.I1: + return KnownTypeCode.SByte; + case PrimitiveType.I2: + return KnownTypeCode.Int16; + case PrimitiveType.I4: + return KnownTypeCode.Int32; + case PrimitiveType.I8: + return KnownTypeCode.Int64; + case PrimitiveType.R4: + return KnownTypeCode.Single; + case PrimitiveType.R8: + case PrimitiveType.R: + return KnownTypeCode.Double; + case PrimitiveType.U1: + return KnownTypeCode.Byte; + case PrimitiveType.U2: + return KnownTypeCode.UInt16; + case PrimitiveType.U4: + return KnownTypeCode.UInt32; + case PrimitiveType.U8: + return KnownTypeCode.UInt64; + case PrimitiveType.I: + return KnownTypeCode.IntPtr; + case PrimitiveType.U: + return KnownTypeCode.UIntPtr; + default: + return KnownTypeCode.None; + } + } + + public static KnownTypeCode ToKnownTypeCode(this StackType stackType, Sign sign = Sign.None) + { + switch (stackType) + { + case StackType.I4: + return sign == Sign.Unsigned ? KnownTypeCode.UInt32 : KnownTypeCode.Int32; + case StackType.I8: + return sign == Sign.Unsigned ? KnownTypeCode.UInt64 : KnownTypeCode.Int64; + case StackType.I: + return sign == Sign.Unsigned ? KnownTypeCode.UIntPtr : KnownTypeCode.IntPtr; + case StackType.F4: + return KnownTypeCode.Single; + case StackType.F8: + return KnownTypeCode.Double; + case StackType.O: + return KnownTypeCode.Object; + case StackType.Void: + return KnownTypeCode.Void; + default: + return KnownTypeCode.None; + } + } + + public static PrimitiveType ToPrimitiveType(this StackType stackType, Sign sign = Sign.None) + { + switch (stackType) + { + case StackType.I4: + return sign == Sign.Unsigned ? PrimitiveType.U4 : PrimitiveType.I4; + case StackType.I8: + return sign == Sign.Unsigned ? PrimitiveType.U8 : PrimitiveType.I8; + case StackType.I: + return sign == Sign.Unsigned ? PrimitiveType.U : PrimitiveType.I; + case StackType.F4: + return PrimitiveType.R4; + case StackType.F8: + return PrimitiveType.R8; + case StackType.Ref: + return PrimitiveType.Ref; + case StackType.Unknown: + return PrimitiveType.Unknown; + default: + return PrimitiveType.None; + } + } + } + + public enum Sign : byte + { + None, + Signed, + Unsigned + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/TypeVisitor.cs b/src/ICSharpCode.Decompiler/TypeSystem/TypeVisitor.cs new file mode 100644 index 0000000..da76087 --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/TypeVisitor.cs @@ -0,0 +1,88 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Base class for the visitor pattern on . + /// + public abstract class TypeVisitor + { + public virtual IType VisitTypeDefinition(ITypeDefinition type) + { + return type.VisitChildren(this); + } + + public virtual IType VisitTypeParameter(ITypeParameter type) + { + return type.VisitChildren(this); + } + + public virtual IType VisitParameterizedType(ParameterizedType type) + { + return type.VisitChildren(this); + } + + public virtual IType VisitArrayType(ArrayType type) + { + return type.VisitChildren(this); + } + + public virtual IType VisitPointerType(PointerType type) + { + return type.VisitChildren(this); + } + + public virtual IType VisitByReferenceType(ByReferenceType type) + { + return type.VisitChildren(this); + } + + public virtual IType VisitTupleType(TupleType type) + { + return type.VisitChildren(this); + } + + public virtual IType VisitOtherType(IType type) + { + return type.VisitChildren(this); + } + + public virtual IType VisitModReq(ModifiedType type) + { + return type.VisitChildren(this); + } + + public virtual IType VisitModOpt(ModifiedType type) + { + return type.VisitChildren(this); + } + + public virtual IType VisitNullabilityAnnotatedType(NullabilityAnnotatedType type) + { + return type.VisitChildren(this); + } + + public virtual IType VisitFunctionPointerType(FunctionPointerType type) + { + return type.VisitChildren(this); + } + } +} diff --git a/src/ICSharpCode.Decompiler/TypeSystem/VarArgInstanceMethod.cs b/src/ICSharpCode.Decompiler/TypeSystem/VarArgInstanceMethod.cs new file mode 100644 index 0000000..7a473ed --- /dev/null +++ b/src/ICSharpCode.Decompiler/TypeSystem/VarArgInstanceMethod.cs @@ -0,0 +1,282 @@ +// Copyright (c) 2016 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Reflection; +using System.Text; + +using ICSharpCode.Decompiler.TypeSystem.Implementation; + +namespace ICSharpCode.Decompiler.TypeSystem +{ + /// + /// Used when calling a vararg method. Stores the actual parameter types being passed. + /// + public class VarArgInstanceMethod : IMethod + { + readonly IMethod baseMethod; + readonly IParameter[] parameters; + + public VarArgInstanceMethod(IMethod baseMethod, IEnumerable varArgTypes) + { + this.baseMethod = baseMethod; + var paramList = new List(baseMethod.Parameters); + Debug.Assert(paramList.Last().Type.Kind == TypeKind.ArgList); + paramList.RemoveAt(paramList.Count - 1); + foreach (var varArg in varArgTypes) + { + paramList.Add(new DefaultParameter(varArg, name: string.Empty, owner: this)); + } + this.parameters = paramList.ToArray(); + } + + public IMethod BaseMethod => baseMethod; + + public int RegularParameterCount { + get { return baseMethod.Parameters.Count - 1; } + } + + public IReadOnlyList Parameters { + get { return parameters; } + } + + public override bool Equals(object obj) + { + var other = obj as VarArgInstanceMethod; + return other != null && baseMethod.Equals(other.baseMethod); + } + + public override int GetHashCode() + { + return baseMethod.GetHashCode(); + } + + public bool Equals(IMember obj, TypeVisitor typeNormalization) + { + var other = obj as VarArgInstanceMethod; + return other != null && baseMethod.Equals(other.baseMethod, typeNormalization); + } + + public override string ToString() + { + var b = new StringBuilder("["); + b.Append(this.SymbolKind); + if (this.DeclaringType != null) + { + b.Append(this.DeclaringType.ReflectionName); + b.Append('.'); + } + b.Append(this.Name); + if (this.TypeParameters.Count > 0) + { + b.Append("``"); + b.Append(this.TypeParameters.Count); + } + b.Append('('); + for (var i = 0; i < this.Parameters.Count; i++) + { + if (i > 0) + b.Append(", "); + if (i == this.RegularParameterCount) + b.Append("..., "); + b.Append(this.Parameters[i].Type.ReflectionName); + } + if (this.Parameters.Count == this.RegularParameterCount) + { + b.Append(", ..."); + } + b.Append("):"); + b.Append(this.ReturnType.ReflectionName); + b.Append(']'); + return b.ToString(); + } + + #region IMethod implementation + public IMethod Specialize(TypeParameterSubstitution substitution) + { + return new VarArgInstanceMethod( + baseMethod.Specialize(substitution), + parameters.Skip(baseMethod.Parameters.Count - 1).Select(p => p.Type.AcceptVisitor(substitution)).ToList()); + } + + IEnumerable IEntity.GetAttributes() => baseMethod.GetAttributes(); + IEnumerable IMethod.GetReturnTypeAttributes() => baseMethod.GetReturnTypeAttributes(); + bool IMethod.ReturnTypeIsRefReadOnly => baseMethod.ReturnTypeIsRefReadOnly; + bool IMethod.ThisIsRefReadOnly => baseMethod.ThisIsRefReadOnly; + bool IMethod.IsInitOnly => baseMethod.IsInitOnly; + + public IReadOnlyList TypeParameters { + get { return baseMethod.TypeParameters; } + } + + public IReadOnlyList TypeArguments { + get { return baseMethod.TypeArguments; } + } + + public System.Reflection.Metadata.EntityHandle MetadataToken => baseMethod.MetadataToken; + + public bool IsExtensionMethod { + get { return baseMethod.IsExtensionMethod; } + } + + bool IMethod.IsLocalFunction { + get { return baseMethod.IsLocalFunction; } + } + + public bool IsConstructor { + get { return baseMethod.IsConstructor; } + } + + public bool IsDestructor { + get { return baseMethod.IsDestructor; } + } + + public bool IsOperator { + get { return baseMethod.IsOperator; } + } + + public bool HasBody { + get { return baseMethod.HasBody; } + } + + public bool IsAccessor => baseMethod.IsAccessor; + public IMember AccessorOwner => baseMethod.AccessorOwner; + public MethodSemanticsAttributes AccessorKind => baseMethod.AccessorKind; + + public IMethod ReducedFrom { + get { return baseMethod.ReducedFrom; } + } + + #endregion + + #region IMember implementation + + IMember IMember.Specialize(TypeParameterSubstitution substitution) + { + return Specialize(substitution); + } + + public IMember MemberDefinition { + get { return baseMethod.MemberDefinition; } + } + + public IType ReturnType { + get { return baseMethod.ReturnType; } + } + + public IEnumerable ExplicitlyImplementedInterfaceMembers { + get { return baseMethod.ExplicitlyImplementedInterfaceMembers; } + } + + public bool IsExplicitInterfaceImplementation { + get { return baseMethod.IsExplicitInterfaceImplementation; } + } + + public bool IsVirtual { + get { return baseMethod.IsVirtual; } + } + + public bool IsOverride { + get { return baseMethod.IsOverride; } + } + + public bool IsOverridable { + get { return baseMethod.IsOverridable; } + } + + public TypeParameterSubstitution Substitution { + get { return baseMethod.Substitution; } + } + + #endregion + + #region ISymbol implementation + + public SymbolKind SymbolKind { + get { return baseMethod.SymbolKind; } + } + + public string Name { + get { return baseMethod.Name; } + } + + #endregion + + #region IEntity implementation + + public ITypeDefinition DeclaringTypeDefinition { + get { return baseMethod.DeclaringTypeDefinition; } + } + + public IType DeclaringType { + get { return baseMethod.DeclaringType; } + } + + public IModule ParentModule { + get { return baseMethod.ParentModule; } + } + + public bool IsStatic { + get { return baseMethod.IsStatic; } + } + + public bool IsAbstract { + get { return baseMethod.IsAbstract; } + } + + public bool IsSealed { + get { return baseMethod.IsSealed; } + } + + #endregion + + #region IHasAccessibility implementation + + public Accessibility Accessibility { + get { return baseMethod.Accessibility; } + } + + #endregion + + #region INamedElement implementation + + public string FullName { + get { return baseMethod.FullName; } + } + + public string ReflectionName { + get { return baseMethod.ReflectionName; } + } + + public string Namespace { + get { return baseMethod.Namespace; } + } + + #endregion + + #region ICompilationProvider implementation + + public ICompilation Compilation { + get { return baseMethod.Compilation; } + } + + #endregion + } +} diff --git a/src/ICSharpCode.Decompiler/Util/BitSet.cs b/src/ICSharpCode.Decompiler/Util/BitSet.cs new file mode 100644 index 0000000..c947845 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/BitSet.cs @@ -0,0 +1,298 @@ +// Copyright (c) 2016 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Diagnostics; +using System.Text; + +namespace ICSharpCode.Decompiler.Util +{ + /// + /// Improved version of BitArray + /// + public class BitSet + { + const int BitsPerWord = 64; + const int Log2BitsPerWord = 6; + const ulong Mask = 0xffffffffffffffffUL; + + readonly ulong[] words; + + static int WordIndex(int bitIndex) + { + Debug.Assert(bitIndex >= 0); + return bitIndex >> Log2BitsPerWord; + } + + /// + /// Creates a new bitset, where initially all bits are zero. + /// + public BitSet(int capacity) + { + this.words = new ulong[Math.Max(1, WordIndex(capacity + BitsPerWord - 1))]; + } + + private BitSet(ulong[] bits) + { + this.words = bits; + } + + public BitSet Clone() + { + return new BitSet((ulong[])words.Clone()); + } + + public bool this[int index] { + get { + return (words[WordIndex(index)] & (1UL << index)) != 0; + } + set { + if (value) + Set(index); + else + Clear(index); + } + } + + /// + /// Gets whether at least one bit is set. + /// + public bool Any() + { + for (var i = 0; i < words.Length; i++) + { + if (words[i] != 0) + return true; + } + return false; + } + + /// + /// Gets whether all bits in the specified range are set. + /// + public bool All(int startIndex, int endIndex) + { + Debug.Assert(startIndex <= endIndex); + if (startIndex >= endIndex) + { + return true; + } + var startWordIndex = WordIndex(startIndex); + var endWordIndex = WordIndex(endIndex - 1); + var startMask = Mask << startIndex; + var endMask = Mask >> -endIndex; // same as (Mask >> (64 - (endIndex % 64))) + if (startWordIndex == endWordIndex) + { + return (words[startWordIndex] & (startMask & endMask)) == (startMask & endMask); + } + else + { + if ((words[startWordIndex] & startMask) != startMask) + return false; + for (var i = startWordIndex + 1; i < endWordIndex; i++) + { + if (words[i] != ulong.MaxValue) + return false; + } + return (words[endWordIndex] & endMask) == endMask; + } + } + + /// + /// Gets whether both bitsets have the same content. + /// + public bool SetEquals(BitSet other) + { + Debug.Assert(words.Length == other.words.Length); + for (var i = 0; i < words.Length; i++) + { + if (words[i] != other.words[i]) + return false; + } + return true; + } + + /// + /// Gets whether this set is a subset of other, or equal. + /// + public bool IsSubsetOf(BitSet other) + { + for (var i = 0; i < words.Length; i++) + { + if ((words[i] & ~other.words[i]) != 0) + return false; + } + return true; + } + + /// + /// Gets whether this set is a superset of other, or equal. + /// + public bool IsSupersetOf(BitSet other) + { + return other.IsSubsetOf(this); + } + + public bool IsProperSubsetOf(BitSet other) + { + return IsSubsetOf(other) && !SetEquals(other); + } + + public bool IsProperSupersetOf(BitSet other) + { + return IsSupersetOf(other) && !SetEquals(other); + } + + /// + /// Gets whether at least one bit is set in both bitsets. + /// + public bool Overlaps(BitSet other) + { + for (var i = 0; i < words.Length; i++) + { + if ((words[i] & other.words[i]) != 0) + return true; + } + return false; + } + + public void UnionWith(BitSet other) + { + Debug.Assert(words.Length == other.words.Length); + for (var i = 0; i < words.Length; i++) + { + words[i] |= other.words[i]; + } + } + + public void IntersectWith(BitSet other) + { + for (var i = 0; i < words.Length; i++) + { + words[i] &= other.words[i]; + } + } + + public void Set(int index) + { + words[WordIndex(index)] |= (1UL << index); + } + + /// + /// Sets all bits i; where startIndex <= i < endIndex. + /// + public void Set(int startIndex, int endIndex) + { + Debug.Assert(startIndex <= endIndex); + if (startIndex >= endIndex) + { + return; + } + var startWordIndex = WordIndex(startIndex); + var endWordIndex = WordIndex(endIndex - 1); + var startMask = Mask << startIndex; + var endMask = Mask >> -endIndex; // same as (Mask >> (64 - (endIndex % 64))) + if (startWordIndex == endWordIndex) + { + words[startWordIndex] |= (startMask & endMask); + } + else + { + words[startWordIndex] |= startMask; + for (var i = startWordIndex + 1; i < endWordIndex; i++) + { + words[i] = ulong.MaxValue; + } + words[endWordIndex] |= endMask; + } + } + + // Note: intentionally no SetAll(), because it would also set the + // extra bits (due to the capacity being rounded up to a full word). + + public void Clear(int index) + { + words[WordIndex(index)] &= ~(1UL << index); + } + + /// + /// Clear all bits i; where startIndex <= i < endIndex. + /// + public void Clear(int startIndex, int endIndex) + { + Debug.Assert(startIndex <= endIndex); + if (startIndex >= endIndex) + { + return; + } + var startWordIndex = WordIndex(startIndex); + var endWordIndex = WordIndex(endIndex - 1); + var startMask = Mask << startIndex; + var endMask = Mask >> -endIndex; // same as (Mask >> (64 - (endIndex % 64))) + if (startWordIndex == endWordIndex) + { + words[startWordIndex] &= ~(startMask & endMask); + } + else + { + words[startWordIndex] &= ~startMask; + for (var i = startWordIndex + 1; i < endWordIndex; i++) + { + words[i] = 0; + } + words[endWordIndex] &= ~endMask; + } + } + + public void ClearAll() + { + for (var i = 0; i < words.Length; i++) + { + words[i] = 0; + } + } + + public void ReplaceWith(BitSet incoming) + { + Debug.Assert(words.Length == incoming.words.Length); + Array.Copy(incoming.words, 0, words, 0, words.Length); + } + + public override string ToString() + { + var b = new StringBuilder(); + b.Append('{'); + for (var i = 0; i < words.Length * BitsPerWord; i++) + { + if (this[i]) + { + if (b.Length > 1) + b.Append(", "); + if (b.Length > 500) + { + b.Append("..."); + break; + } + b.Append(i); + } + } + b.Append('}'); + return b.ToString(); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/BusyManager.cs b/src/ICSharpCode.Decompiler/Util/BusyManager.cs new file mode 100644 index 0000000..c05bf85 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/BusyManager.cs @@ -0,0 +1,75 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.Util +{ + /// + /// This class is used to prevent stack overflows by representing a 'busy' flag + /// that prevents reentrance when another call is running. + /// However, using a simple 'bool busy' is not thread-safe, so we use a + /// thread-static BusyManager. + /// + public static class BusyManager + { + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1815:OverrideEqualsAndOperatorEqualsOnValueTypes")] + [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible", + Justification = "Should always be used with 'var'")] + public struct BusyLock : IDisposable + { + public static readonly BusyLock Failed = new BusyLock(null); + + readonly List objectList; + + internal BusyLock(List objectList) + { + this.objectList = objectList; + } + + public bool Success { + get { return objectList != null; } + } + + public void Dispose() + { + if (objectList != null) + { + objectList.RemoveAt(objectList.Count - 1); + } + } + } + + [ThreadStatic] static List _activeObjects; + + public static BusyLock Enter(object obj) + { + var activeObjects = _activeObjects; + if (activeObjects == null) + activeObjects = _activeObjects = new List(); + for (var i = 0; i < activeObjects.Count; i++) + { + if (activeObjects[i] == obj) + return BusyLock.Failed; + } + activeObjects.Add(obj); + return new BusyLock(activeObjects); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/CSharpPrimitiveCast.cs b/src/ICSharpCode.Decompiler/Util/CSharpPrimitiveCast.cs new file mode 100644 index 0000000..65e3ea4 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/CSharpPrimitiveCast.cs @@ -0,0 +1,771 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +namespace ICSharpCode.Decompiler.Util +{ + /// + /// Static helper method for converting between primitive types. + /// + public static class CSharpPrimitiveCast + { + /// + /// Performs a conversion between primitive types. + /// Unfortunately we cannot use Convert.ChangeType because it has different semantics + /// (e.g. rounding behavior for floats, overflow, etc.), so we write down every possible primitive C# cast + /// and let the compiler figure out the exact semantics. + /// And we have to do everything twice, once in a checked-block, once in an unchecked-block. + /// + /// Overflow checking is enabled and an overflow occurred. + /// The cast is invalid, e.g. casting a boolean to an integer. + public static object Cast(TypeCode targetType, object input, bool checkForOverflow) + { + if (input == null) + return null; + if (checkForOverflow) + return CSharpPrimitiveCastChecked(targetType, input); + else + return CSharpPrimitiveCastUnchecked(targetType, input); + } + + static object CSharpPrimitiveCastChecked(TypeCode targetType, object input) + { + checked + { + var sourceType = Type.GetTypeCode(input.GetType()); + if (sourceType == targetType) + return input; + switch (targetType) + { + case TypeCode.Char: + switch (sourceType) + { + case TypeCode.SByte: + return (char)(sbyte)input; + case TypeCode.Byte: + return (char)(byte)input; + case TypeCode.Int16: + return (char)(short)input; + case TypeCode.UInt16: + return (char)(ushort)input; + case TypeCode.Int32: + return (char)(int)input; + case TypeCode.UInt32: + return (char)(uint)input; + case TypeCode.Int64: + return (char)(long)input; + case TypeCode.UInt64: + return (char)(ulong)input; + case TypeCode.Single: + return (char)(float)input; + case TypeCode.Double: + return (char)(double)input; + case TypeCode.Decimal: + return (char)(decimal)input; + case TypeCode.Boolean: + return (char)((bool)input ? 1 : 0); + } + break; + case TypeCode.SByte: + switch (sourceType) + { + case TypeCode.Char: + return (sbyte)(char)input; + case TypeCode.Byte: + return (sbyte)(byte)input; + case TypeCode.Int16: + return (sbyte)(short)input; + case TypeCode.UInt16: + return (sbyte)(ushort)input; + case TypeCode.Int32: + return (sbyte)(int)input; + case TypeCode.UInt32: + return (sbyte)(uint)input; + case TypeCode.Int64: + return (sbyte)(long)input; + case TypeCode.UInt64: + return (sbyte)(ulong)input; + case TypeCode.Single: + return (sbyte)(float)input; + case TypeCode.Double: + return (sbyte)(double)input; + case TypeCode.Decimal: + return (sbyte)(decimal)input; + case TypeCode.Boolean: + return (sbyte)((bool)input ? 1 : 0); + } + break; + case TypeCode.Byte: + switch (sourceType) + { + case TypeCode.Char: + return (byte)(char)input; + case TypeCode.SByte: + return (byte)(sbyte)input; + case TypeCode.Int16: + return (byte)(short)input; + case TypeCode.UInt16: + return (byte)(ushort)input; + case TypeCode.Int32: + return (byte)(int)input; + case TypeCode.UInt32: + return (byte)(uint)input; + case TypeCode.Int64: + return (byte)(long)input; + case TypeCode.UInt64: + return (byte)(ulong)input; + case TypeCode.Single: + return (byte)(float)input; + case TypeCode.Double: + return (byte)(double)input; + case TypeCode.Decimal: + return (byte)(decimal)input; + case TypeCode.Boolean: + return (byte)((bool)input ? 1 : 0); + } + break; + case TypeCode.Int16: + switch (sourceType) + { + case TypeCode.Char: + return (short)(char)input; + case TypeCode.SByte: + return (short)(sbyte)input; + case TypeCode.Byte: + return (short)(byte)input; + case TypeCode.UInt16: + return (short)(ushort)input; + case TypeCode.Int32: + return (short)(int)input; + case TypeCode.UInt32: + return (short)(uint)input; + case TypeCode.Int64: + return (short)(long)input; + case TypeCode.UInt64: + return (short)(ulong)input; + case TypeCode.Single: + return (short)(float)input; + case TypeCode.Double: + return (short)(double)input; + case TypeCode.Decimal: + return (short)(decimal)input; + case TypeCode.Boolean: + return (short)((bool)input ? 1 : 0); + } + break; + case TypeCode.UInt16: + switch (sourceType) + { + case TypeCode.Char: + return (ushort)(char)input; + case TypeCode.SByte: + return (ushort)(sbyte)input; + case TypeCode.Byte: + return (ushort)(byte)input; + case TypeCode.Int16: + return (ushort)(short)input; + case TypeCode.Int32: + return (ushort)(int)input; + case TypeCode.UInt32: + return (ushort)(uint)input; + case TypeCode.Int64: + return (ushort)(long)input; + case TypeCode.UInt64: + return (ushort)(ulong)input; + case TypeCode.Single: + return (ushort)(float)input; + case TypeCode.Double: + return (ushort)(double)input; + case TypeCode.Decimal: + return (ushort)(decimal)input; + case TypeCode.Boolean: + return (ushort)((bool)input ? 1 : 0); + } + break; + case TypeCode.Int32: + switch (sourceType) + { + case TypeCode.Char: + return (int)(char)input; + case TypeCode.SByte: + return (int)(sbyte)input; + case TypeCode.Byte: + return (int)(byte)input; + case TypeCode.Int16: + return (int)(short)input; + case TypeCode.UInt16: + return (int)(ushort)input; + case TypeCode.UInt32: + return (int)(uint)input; + case TypeCode.Int64: + return (int)(long)input; + case TypeCode.UInt64: + return (int)(ulong)input; + case TypeCode.Single: + return (int)(float)input; + case TypeCode.Double: + return (int)(double)input; + case TypeCode.Decimal: + return (int)(decimal)input; + case TypeCode.Boolean: + return (int)((bool)input ? 1 : 0); + } + break; + case TypeCode.UInt32: + switch (sourceType) + { + case TypeCode.Char: + return (uint)(char)input; + case TypeCode.SByte: + return (uint)(sbyte)input; + case TypeCode.Byte: + return (uint)(byte)input; + case TypeCode.Int16: + return (uint)(short)input; + case TypeCode.UInt16: + return (uint)(ushort)input; + case TypeCode.Int32: + return (uint)(int)input; + case TypeCode.Int64: + return (uint)(long)input; + case TypeCode.UInt64: + return (uint)(ulong)input; + case TypeCode.Single: + return (uint)(float)input; + case TypeCode.Double: + return (uint)(double)input; + case TypeCode.Decimal: + return (uint)(decimal)input; + case TypeCode.Boolean: + return (uint)((bool)input ? 1 : 0); + } + break; + case TypeCode.Int64: + switch (sourceType) + { + case TypeCode.Char: + return (long)(char)input; + case TypeCode.SByte: + return (long)(sbyte)input; + case TypeCode.Byte: + return (long)(byte)input; + case TypeCode.Int16: + return (long)(short)input; + case TypeCode.UInt16: + return (long)(ushort)input; + case TypeCode.Int32: + return (long)(int)input; + case TypeCode.UInt32: + return (long)(uint)input; + case TypeCode.UInt64: + return (long)(ulong)input; + case TypeCode.Single: + return (long)(float)input; + case TypeCode.Double: + return (long)(double)input; + case TypeCode.Decimal: + return (long)(decimal)input; + case TypeCode.Boolean: + return (long)((bool)input ? 1 : 0); + } + break; + case TypeCode.UInt64: + switch (sourceType) + { + case TypeCode.Char: + return (ulong)(char)input; + case TypeCode.SByte: + return (ulong)(sbyte)input; + case TypeCode.Byte: + return (ulong)(byte)input; + case TypeCode.Int16: + return (ulong)(short)input; + case TypeCode.UInt16: + return (ulong)(ushort)input; + case TypeCode.Int32: + return (ulong)(int)input; + case TypeCode.UInt32: + return (ulong)(uint)input; + case TypeCode.Int64: + return (ulong)(long)input; + case TypeCode.Single: + return (ulong)(float)input; + case TypeCode.Double: + return (ulong)(double)input; + case TypeCode.Decimal: + return (ulong)(decimal)input; + case TypeCode.Boolean: + return (ulong)((bool)input ? 1 : 0); + } + break; + case TypeCode.Single: + switch (sourceType) + { + case TypeCode.Char: + return (float)(char)input; + case TypeCode.SByte: + return (float)(sbyte)input; + case TypeCode.Byte: + return (float)(byte)input; + case TypeCode.Int16: + return (float)(short)input; + case TypeCode.UInt16: + return (float)(ushort)input; + case TypeCode.Int32: + return (float)(int)input; + case TypeCode.UInt32: + return (float)(uint)input; + case TypeCode.Int64: + return (float)(long)input; + case TypeCode.UInt64: + return (float)(ulong)input; + case TypeCode.Double: + return (float)(double)input; + case TypeCode.Decimal: + return (float)(decimal)input; + case TypeCode.Boolean: + return (float)((bool)input ? 1 : 0); + } + break; + case TypeCode.Double: + switch (sourceType) + { + case TypeCode.Char: + return (double)(char)input; + case TypeCode.SByte: + return (double)(sbyte)input; + case TypeCode.Byte: + return (double)(byte)input; + case TypeCode.Int16: + return (double)(short)input; + case TypeCode.UInt16: + return (double)(ushort)input; + case TypeCode.Int32: + return (double)(int)input; + case TypeCode.UInt32: + return (double)(uint)input; + case TypeCode.Int64: + return (double)(long)input; + case TypeCode.UInt64: + return (double)(ulong)input; + case TypeCode.Single: + return (double)(float)input; + case TypeCode.Decimal: + return (double)(decimal)input; + case TypeCode.Boolean: + return (double)((bool)input ? 1 : 0); + } + break; + case TypeCode.Decimal: + switch (sourceType) + { + case TypeCode.Char: + return (decimal)(char)input; + case TypeCode.SByte: + return (decimal)(sbyte)input; + case TypeCode.Byte: + return (decimal)(byte)input; + case TypeCode.Int16: + return (decimal)(short)input; + case TypeCode.UInt16: + return (decimal)(ushort)input; + case TypeCode.Int32: + return (decimal)(int)input; + case TypeCode.UInt32: + return (decimal)(uint)input; + case TypeCode.Int64: + return (decimal)(long)input; + case TypeCode.UInt64: + return (decimal)(ulong)input; + case TypeCode.Single: + return (decimal)(float)input; + case TypeCode.Double: + return (decimal)(double)input; + case TypeCode.Boolean: + return (decimal)((bool)input ? 1 : 0); + } + break; + } + throw new InvalidCastException("Cast from " + sourceType + " to " + targetType + "not supported."); + } + } + + static object CSharpPrimitiveCastUnchecked(TypeCode targetType, object input) + { + unchecked + { + var sourceType = Type.GetTypeCode(input.GetType()); + if (sourceType == targetType) + return input; + switch (targetType) + { + case TypeCode.Char: + switch (sourceType) + { + case TypeCode.SByte: + return (char)(sbyte)input; + case TypeCode.Byte: + return (char)(byte)input; + case TypeCode.Int16: + return (char)(short)input; + case TypeCode.UInt16: + return (char)(ushort)input; + case TypeCode.Int32: + return (char)(int)input; + case TypeCode.UInt32: + return (char)(uint)input; + case TypeCode.Int64: + return (char)(long)input; + case TypeCode.UInt64: + return (char)(ulong)input; + case TypeCode.Single: + return (char)(float)input; + case TypeCode.Double: + return (char)(double)input; + case TypeCode.Decimal: + return (char)(decimal)input; + case TypeCode.Boolean: + return (char)((bool)input ? 1 : 0); + } + break; + case TypeCode.SByte: + switch (sourceType) + { + case TypeCode.Char: + return (sbyte)(char)input; + case TypeCode.Byte: + return (sbyte)(byte)input; + case TypeCode.Int16: + return (sbyte)(short)input; + case TypeCode.UInt16: + return (sbyte)(ushort)input; + case TypeCode.Int32: + return (sbyte)(int)input; + case TypeCode.UInt32: + return (sbyte)(uint)input; + case TypeCode.Int64: + return (sbyte)(long)input; + case TypeCode.UInt64: + return (sbyte)(ulong)input; + case TypeCode.Single: + return (sbyte)(float)input; + case TypeCode.Double: + return (sbyte)(double)input; + case TypeCode.Decimal: + return (sbyte)(decimal)input; + case TypeCode.Boolean: + return (sbyte)((bool)input ? 1 : 0); + } + break; + case TypeCode.Byte: + switch (sourceType) + { + case TypeCode.Char: + return (byte)(char)input; + case TypeCode.SByte: + return (byte)(sbyte)input; + case TypeCode.Int16: + return (byte)(short)input; + case TypeCode.UInt16: + return (byte)(ushort)input; + case TypeCode.Int32: + return (byte)(int)input; + case TypeCode.UInt32: + return (byte)(uint)input; + case TypeCode.Int64: + return (byte)(long)input; + case TypeCode.UInt64: + return (byte)(ulong)input; + case TypeCode.Single: + return (byte)(float)input; + case TypeCode.Double: + return (byte)(double)input; + case TypeCode.Decimal: + return (byte)(decimal)input; + case TypeCode.Boolean: + return (byte)((bool)input ? 1 : 0); + } + break; + case TypeCode.Int16: + switch (sourceType) + { + case TypeCode.Char: + return (short)(char)input; + case TypeCode.SByte: + return (short)(sbyte)input; + case TypeCode.Byte: + return (short)(byte)input; + case TypeCode.UInt16: + return (short)(ushort)input; + case TypeCode.Int32: + return (short)(int)input; + case TypeCode.UInt32: + return (short)(uint)input; + case TypeCode.Int64: + return (short)(long)input; + case TypeCode.UInt64: + return (short)(ulong)input; + case TypeCode.Single: + return (short)(float)input; + case TypeCode.Double: + return (short)(double)input; + case TypeCode.Decimal: + return (short)(decimal)input; + case TypeCode.Boolean: + return (short)((bool)input ? 1 : 0); + } + break; + case TypeCode.UInt16: + switch (sourceType) + { + case TypeCode.Char: + return (ushort)(char)input; + case TypeCode.SByte: + return (ushort)(sbyte)input; + case TypeCode.Byte: + return (ushort)(byte)input; + case TypeCode.Int16: + return (ushort)(short)input; + case TypeCode.Int32: + return (ushort)(int)input; + case TypeCode.UInt32: + return (ushort)(uint)input; + case TypeCode.Int64: + return (ushort)(long)input; + case TypeCode.UInt64: + return (ushort)(ulong)input; + case TypeCode.Single: + return (ushort)(float)input; + case TypeCode.Double: + return (ushort)(double)input; + case TypeCode.Decimal: + return (ushort)(decimal)input; + case TypeCode.Boolean: + return (ushort)((bool)input ? 1 : 0); + } + break; + case TypeCode.Int32: + switch (sourceType) + { + case TypeCode.Char: + return (int)(char)input; + case TypeCode.SByte: + return (int)(sbyte)input; + case TypeCode.Byte: + return (int)(byte)input; + case TypeCode.Int16: + return (int)(short)input; + case TypeCode.UInt16: + return (int)(ushort)input; + case TypeCode.UInt32: + return (int)(uint)input; + case TypeCode.Int64: + return (int)(long)input; + case TypeCode.UInt64: + return (int)(ulong)input; + case TypeCode.Single: + return (int)(float)input; + case TypeCode.Double: + return (int)(double)input; + case TypeCode.Decimal: + return (int)(decimal)input; + case TypeCode.Boolean: + return (int)((bool)input ? 1 : 0); + } + break; + case TypeCode.UInt32: + switch (sourceType) + { + case TypeCode.Char: + return (uint)(char)input; + case TypeCode.SByte: + return (uint)(sbyte)input; + case TypeCode.Byte: + return (uint)(byte)input; + case TypeCode.Int16: + return (uint)(short)input; + case TypeCode.UInt16: + return (uint)(ushort)input; + case TypeCode.Int32: + return (uint)(int)input; + case TypeCode.Int64: + return (uint)(long)input; + case TypeCode.UInt64: + return (uint)(ulong)input; + case TypeCode.Single: + return (uint)(float)input; + case TypeCode.Double: + return (uint)(double)input; + case TypeCode.Decimal: + return (uint)(decimal)input; + case TypeCode.Boolean: + return (uint)((bool)input ? 1 : 0); + } + break; + case TypeCode.Int64: + switch (sourceType) + { + case TypeCode.Char: + return (long)(char)input; + case TypeCode.SByte: + return (long)(sbyte)input; + case TypeCode.Byte: + return (long)(byte)input; + case TypeCode.Int16: + return (long)(short)input; + case TypeCode.UInt16: + return (long)(ushort)input; + case TypeCode.Int32: + return (long)(int)input; + case TypeCode.UInt32: + return (long)(uint)input; + case TypeCode.UInt64: + return (long)(ulong)input; + case TypeCode.Single: + return (long)(float)input; + case TypeCode.Double: + return (long)(double)input; + case TypeCode.Decimal: + return (long)(decimal)input; + case TypeCode.Boolean: + return (long)((bool)input ? 1 : 0); + } + break; + case TypeCode.UInt64: + switch (sourceType) + { + case TypeCode.Char: + return (ulong)(char)input; + case TypeCode.SByte: + return (ulong)(sbyte)input; + case TypeCode.Byte: + return (ulong)(byte)input; + case TypeCode.Int16: + return (ulong)(short)input; + case TypeCode.UInt16: + return (ulong)(ushort)input; + case TypeCode.Int32: + return (ulong)(int)input; + case TypeCode.UInt32: + return (ulong)(uint)input; + case TypeCode.Int64: + return (ulong)(long)input; + case TypeCode.Single: + return (ulong)(float)input; + case TypeCode.Double: + return (ulong)(double)input; + case TypeCode.Decimal: + return (ulong)(decimal)input; + case TypeCode.Boolean: + return (ulong)((bool)input ? 1 : 0); + } + break; + case TypeCode.Single: + switch (sourceType) + { + case TypeCode.Char: + return (float)(char)input; + case TypeCode.SByte: + return (float)(sbyte)input; + case TypeCode.Byte: + return (float)(byte)input; + case TypeCode.Int16: + return (float)(short)input; + case TypeCode.UInt16: + return (float)(ushort)input; + case TypeCode.Int32: + return (float)(int)input; + case TypeCode.UInt32: + return (float)(uint)input; + case TypeCode.Int64: + return (float)(long)input; + case TypeCode.UInt64: + return (float)(ulong)input; + case TypeCode.Double: + return (float)(double)input; + case TypeCode.Decimal: + return (float)(decimal)input; + case TypeCode.Boolean: + return (float)((bool)input ? 1 : 0); + } + break; + case TypeCode.Double: + switch (sourceType) + { + case TypeCode.Char: + return (double)(char)input; + case TypeCode.SByte: + return (double)(sbyte)input; + case TypeCode.Byte: + return (double)(byte)input; + case TypeCode.Int16: + return (double)(short)input; + case TypeCode.UInt16: + return (double)(ushort)input; + case TypeCode.Int32: + return (double)(int)input; + case TypeCode.UInt32: + return (double)(uint)input; + case TypeCode.Int64: + return (double)(long)input; + case TypeCode.UInt64: + return (double)(ulong)input; + case TypeCode.Single: + return (double)(float)input; + case TypeCode.Decimal: + return (double)(decimal)input; + case TypeCode.Boolean: + return (double)((bool)input ? 1 : 0); + } + break; + case TypeCode.Decimal: + switch (sourceType) + { + case TypeCode.Char: + return (decimal)(char)input; + case TypeCode.SByte: + return (decimal)(sbyte)input; + case TypeCode.Byte: + return (decimal)(byte)input; + case TypeCode.Int16: + return (decimal)(short)input; + case TypeCode.UInt16: + return (decimal)(ushort)input; + case TypeCode.Int32: + return (decimal)(int)input; + case TypeCode.UInt32: + return (decimal)(uint)input; + case TypeCode.Int64: + return (decimal)(long)input; + case TypeCode.UInt64: + return (decimal)(ulong)input; + case TypeCode.Single: + return (decimal)(float)input; + case TypeCode.Double: + return (decimal)(double)input; + case TypeCode.Boolean: + return (decimal)((bool)input ? 1 : 0); + } + break; + } + throw new InvalidCastException("Cast from " + sourceType + " to " + targetType + " not supported."); + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/CacheManager.cs b/src/ICSharpCode.Decompiler/Util/CacheManager.cs new file mode 100644 index 0000000..75bef22 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/CacheManager.cs @@ -0,0 +1,57 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Concurrent; + +namespace ICSharpCode.Decompiler.Util +{ + /// + /// Allows caching values for a specific compilation. + /// A CacheManager consists of a for shared instances (shared among all threads working with that resolve context). + /// + /// This class is thread-safe + public sealed class CacheManager + { + readonly ConcurrentDictionary sharedDict = new ConcurrentDictionary(ReferenceComparer.Instance); + // There used to be a thread-local dictionary here, but I removed it as it was causing memory + // leaks in some use cases. + + public object GetShared(object key) + { + object value; + sharedDict.TryGetValue(key, out value); + return value; + } + + public object GetOrAddShared(object key, Func valueFactory) + { + return sharedDict.GetOrAdd(key, valueFactory); + } + + public object GetOrAddShared(object key, object value) + { + return sharedDict.GetOrAdd(key, value); + } + + public void SetShared(object key, object value) + { + sharedDict[key] = value; + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/CallbackOnDispose.cs b/src/ICSharpCode.Decompiler/Util/CallbackOnDispose.cs new file mode 100644 index 0000000..08f4583 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/CallbackOnDispose.cs @@ -0,0 +1,51 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Threading; + +namespace ICSharpCode.Decompiler.Util +{ + /// + /// Invokes an action when it is disposed. + /// + /// + /// This class ensures the callback is invoked at most once, + /// even when Dispose is called on multiple threads. + /// + public sealed class CallbackOnDispose : IDisposable + { + Action action; + + public CallbackOnDispose(Action action) + { + if (action == null) + throw new ArgumentNullException(nameof(action)); + this.action = action; + } + + public void Dispose() + { + var a = Interlocked.Exchange(ref action, null); + if (a != null) + { + a(); + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/CollectionExtensions.cs b/src/ICSharpCode.Decompiler/Util/CollectionExtensions.cs new file mode 100644 index 0000000..0b41395 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/CollectionExtensions.cs @@ -0,0 +1,387 @@ +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Linq; + +namespace ICSharpCode.Decompiler.Util +{ + static class CollectionExtensions + { + public static void Deconstruct(this KeyValuePair pair, out K key, out V value) + { + key = pair.Key; + value = pair.Value; + } + +#if !NETCORE + public static IEnumerable<(A, B)> Zip(this IEnumerable input1, IEnumerable input2) + { + return input1.Zip(input2, (a, b) => (a, b)); + } +#endif + + public static IEnumerable<(A, B)> ZipLongest(this IEnumerable input1, IEnumerable input2) + { + using (var it1 = input1.GetEnumerator()) + { + using (var it2 = input2.GetEnumerator()) + { + var hasElements1 = true; + var hasElements2 = true; + while (true) + { + if (hasElements1) + hasElements1 = it1.MoveNext(); + if (hasElements2) + hasElements2 = it2.MoveNext(); + if (!(hasElements1 || hasElements2)) + break; + yield return ((hasElements1 ? it1.Current : default), (hasElements2 ? it2.Current : default)); + } + } + } + } + + public static IEnumerable Slice(this IReadOnlyList input, int offset, int length) + { + for (var i = offset; i < offset + length; i++) + { + yield return input[i]; + } + } + + public static IEnumerable Slice(this IReadOnlyList input, int offset) + { + var length = input.Count; + for (var i = offset; i < length; i++) + { + yield return input[i]; + } + } + +#if !NETCORE + public static HashSet ToHashSet(this IEnumerable input) + { + return new HashSet(input); + } +#endif + + public static IEnumerable SkipLast(this IReadOnlyCollection input, int count) + { + return input.Take(input.Count - count); + } + + public static IEnumerable TakeLast(this IReadOnlyCollection input, int count) + { + return input.Skip(input.Count - count); + } + + public static T PopOrDefault(this Stack stack) + { + if (stack.Count == 0) + return default(T); + return stack.Pop(); + } + + public static T PeekOrDefault(this Stack stack) + { + if (stack.Count == 0) + return default(T); + return stack.Peek(); + } + + public static int MaxOrDefault(this IEnumerable input, Func selector, int defaultValue = 0) + { + var max = defaultValue; + foreach (var element in input) + { + var value = selector(element); + if (value > max) + max = value; + } + return max; + } + + public static int IndexOf(this IReadOnlyList collection, T value) + { + var comparer = EqualityComparer.Default; + var index = 0; + foreach (var item in collection) + { + if (comparer.Equals(item, value)) + { + return index; + } + index++; + } + return -1; + } + + public static void AddRange(this ICollection collection, IEnumerable input) + { + foreach (var item in input) + collection.Add(item); + } + + /// + /// Equivalent to collection.Select(func).ToArray(), but more efficient as it makes + /// use of the input collection's known size. + /// + public static U[] SelectArray(this ICollection collection, Func func) + { + var result = new U[collection.Count]; + var index = 0; + foreach (var element in collection) + { + result[index++] = func(element); + } + return result; + } + + /// + /// Equivalent to collection.Select(func).ToImmutableArray(), but more efficient as it makes + /// use of the input collection's known size. + /// + public static ImmutableArray SelectImmutableArray(this IReadOnlyCollection collection, Func func) + { + var builder = ImmutableArray.CreateBuilder(collection.Count); + foreach (var element in collection) + { + builder.Add(func(element)); + } + return builder.MoveToImmutable(); + } + + /// + /// Equivalent to collection.Select(func).ToArray(), but more efficient as it makes + /// use of the input collection's known size. + /// + public static U[] SelectReadOnlyArray(this IReadOnlyCollection collection, Func func) + { + var result = new U[collection.Count]; + var index = 0; + foreach (var element in collection) + { + result[index++] = func(element); + } + return result; + } + + /// + /// Equivalent to collection.Select(func).ToArray(), but more efficient as it makes + /// use of the input collection's known size. + /// + public static U[] SelectArray(this List collection, Func func) + { + var result = new U[collection.Count]; + var index = 0; + foreach (var element in collection) + { + result[index++] = func(element); + } + return result; + } + + /// + /// Equivalent to collection.Select(func).ToArray(), but more efficient as it makes + /// use of the input collection's known size. + /// + public static U[] SelectArray(this T[] collection, Func func) + { + var result = new U[collection.Length]; + var index = 0; + foreach (var element in collection) + { + result[index++] = func(element); + } + return result; + } + + /// + /// Equivalent to collection.Select(func).ToList(), but more efficient as it makes + /// use of the input collection's known size. + /// + public static List SelectList(this ICollection collection, Func func) + { + var result = new List(collection.Count); + foreach (var element in collection) + { + result.Add(func(element)); + } + return result; + } + + public static IEnumerable SelectWithIndex(this IEnumerable source, Func func) + { + var index = 0; + foreach (var element in source) + yield return func(index++, element); + } + + public static IEnumerable<(int, T)> WithIndex(this ICollection source) + { + var index = 0; + foreach (var item in source) + { + yield return (index, item); + index++; + } + } + + /// + /// The merge step of merge sort. + /// + public static IEnumerable Merge(this IEnumerable input1, IEnumerable input2, Comparison comparison) + { + using (var enumA = input1.GetEnumerator()) + using (var enumB = input2.GetEnumerator()) + { + var moreA = enumA.MoveNext(); + var moreB = enumB.MoveNext(); + while (moreA && moreB) + { + if (comparison(enumA.Current, enumB.Current) <= 0) + { + yield return enumA.Current; + moreA = enumA.MoveNext(); + } + else + { + yield return enumB.Current; + moreB = enumB.MoveNext(); + } + } + while (moreA) + { + yield return enumA.Current; + moreA = enumA.MoveNext(); + } + while (moreB) + { + yield return enumB.Current; + moreB = enumB.MoveNext(); + } + } + } + + /// + /// Returns the minimum element. + /// + /// The input sequence is empty + public static T MinBy(this IEnumerable source, Func keySelector) where K : IComparable + { + return source.MinBy(keySelector, Comparer.Default); + } + + /// + /// Returns the minimum element. + /// + /// The input sequence is empty + public static T MinBy(this IEnumerable source, Func keySelector, IComparer keyComparer) + { + if (source == null) + throw new ArgumentNullException(nameof(source)); + if (keySelector == null) + throw new ArgumentNullException(nameof(keySelector)); + if (keyComparer == null) + keyComparer = Comparer.Default; + using (var enumerator = source.GetEnumerator()) + { + if (!enumerator.MoveNext()) + throw new InvalidOperationException("Sequence contains no elements"); + var minElement = enumerator.Current; + var minKey = keySelector(minElement); + while (enumerator.MoveNext()) + { + var element = enumerator.Current; + var key = keySelector(element); + if (keyComparer.Compare(key, minKey) < 0) + { + minElement = element; + minKey = key; + } + } + return minElement; + } + } + + /// + /// Returns the maximum element. + /// + /// The input sequence is empty + public static T MaxBy(this IEnumerable source, Func keySelector) where K : IComparable + { + return source.MaxBy(keySelector, Comparer.Default); + } + + /// + /// Returns the maximum element. + /// + /// The input sequence is empty + public static T MaxBy(this IEnumerable source, Func keySelector, IComparer keyComparer) + { + if (source == null) + throw new ArgumentNullException(nameof(source)); + if (keySelector == null) + throw new ArgumentNullException(nameof(keySelector)); + if (keyComparer == null) + keyComparer = Comparer.Default; + using (var enumerator = source.GetEnumerator()) + { + if (!enumerator.MoveNext()) + throw new InvalidOperationException("Sequence contains no elements"); + var maxElement = enumerator.Current; + var maxKey = keySelector(maxElement); + while (enumerator.MoveNext()) + { + var element = enumerator.Current; + var key = keySelector(element); + if (keyComparer.Compare(key, maxKey) > 0) + { + maxElement = element; + maxKey = key; + } + } + return maxElement; + } + } + + public static void RemoveLast(this IList list) + { + if (list == null) + throw new ArgumentNullException(nameof(list)); + list.RemoveAt(list.Count - 1); + } + + public static T OnlyOrDefault(this IEnumerable source, Func predicate) => OnlyOrDefault(source.Where(predicate)); + + public static T OnlyOrDefault(this IEnumerable source) + { + var any = false; + T first = default; + foreach (var t in source) + { + if (any) + return default(T); + first = t; + any = true; + } + + return first; + } + + #region Aliases/shortcuts for Enumerable extension methods + public static bool Any(this ICollection list) => list.Count > 0; + public static bool Any(this T[] array, Predicate match) => Array.Exists(array, match); + public static bool Any(this List list, Predicate match) => list.Exists(match); + + public static bool All(this T[] array, Predicate match) => Array.TrueForAll(array, match); + public static bool All(this List list, Predicate match) => list.TrueForAll(match); + + public static T FirstOrDefault(this T[] array, Predicate predicate) => Array.Find(array, predicate); + public static T FirstOrDefault(this List list, Predicate predicate) => list.Find(predicate); + + public static T Last(this IList list) => list[list.Count - 1]; + #endregion + } +} diff --git a/src/ICSharpCode.Decompiler/Util/EmptyList.cs b/src/ICSharpCode.Decompiler/Util/EmptyList.cs new file mode 100644 index 0000000..2b4e6c4 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/EmptyList.cs @@ -0,0 +1,121 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections; +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.Util +{ + [Serializable] + public sealed class EmptyList : IList, IEnumerator, IReadOnlyList + { + public static readonly EmptyList Instance = new EmptyList(); + + private EmptyList() { } + + public T this[int index] { + get { throw new ArgumentOutOfRangeException(nameof(index)); } + set { throw new ArgumentOutOfRangeException(nameof(index)); } + } + + public int Count { + get { return 0; } + } + + bool ICollection.IsReadOnly { + get { return true; } + } + + int IList.IndexOf(T item) + { + return -1; + } + + void IList.Insert(int index, T item) + { + throw new NotSupportedException(); + } + + void IList.RemoveAt(int index) + { + throw new NotSupportedException(); + } + + void ICollection.Add(T item) + { + throw new NotSupportedException(); + } + + void ICollection.Clear() + { + } + + bool ICollection.Contains(T item) + { + return false; + } + + void ICollection.CopyTo(T[] array, int arrayIndex) + { + } + + bool ICollection.Remove(T item) + { + return false; + } + + IEnumerator IEnumerable.GetEnumerator() + { + return this; + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return this; + } + + T IEnumerator.Current { + get { return default(T); } + } + + object IEnumerator.Current { + get { return default(T); } + } + + void IDisposable.Dispose() + { + } + + bool IEnumerator.MoveNext() + { + return false; + } + + void IEnumerator.Reset() + { + } + } + + public static class Empty + { + public static readonly T[] Array = System.Array.Empty(); + } + + public struct Unit { } +} diff --git a/src/ICSharpCode.Decompiler/Util/ExtensionMethods.cs b/src/ICSharpCode.Decompiler/Util/ExtensionMethods.cs new file mode 100644 index 0000000..f21d98f --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/ExtensionMethods.cs @@ -0,0 +1,44 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +namespace ICSharpCode.Decompiler.Util +{ + /// + /// Contains extension methods for internal use within the decompiler. + /// + static class ExtensionMethods + { + public static Predicate And(this Predicate filter1, Predicate filter2) + { + if (filter1 == null) + return filter2; + if (filter2 == null) + return filter1; + return m => filter1(m) && filter2(m); + } + + public static void Swap(ref T a, ref T b) + { + var tmp = a; + a = b; + b = tmp; + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/FileUtility.cs b/src/ICSharpCode.Decompiler/Util/FileUtility.cs new file mode 100644 index 0000000..f208806 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/FileUtility.cs @@ -0,0 +1,304 @@ +// Copyright (c) 2020 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.IO; +using System.Text; + +namespace ICSharpCode.Decompiler.Util +{ + static class FileUtility + { + /// + /// Gets the normalized version of fileName. + /// Slashes are replaced with backslashes, backreferences "." and ".." are 'evaluated'. + /// + public static string NormalizePath(string fileName) + { + if (string.IsNullOrEmpty(fileName)) + return fileName; + + int i; + + var isWeb = false; + for (i = 0; i < fileName.Length; i++) + { + if (fileName[i] == '/' || fileName[i] == '\\') + break; + if (fileName[i] == ':') + { + if (i > 1) + isWeb = true; + break; + } + } + + var outputSeparator = '/'; + bool isRelative; + var isAbsoluteUnixPath = false; + + var result = new StringBuilder(); + if (isWeb == false && IsUNCPath(fileName)) + { + // UNC path + i = 2; + outputSeparator = '\\'; + result.Append(outputSeparator); + isRelative = false; + } + else + { + i = 0; + isAbsoluteUnixPath = fileName[0] == '/'; + isRelative = !isWeb && !isAbsoluteUnixPath && (fileName.Length < 2 || fileName[1] != ':'); + if (fileName.Length >= 2 && fileName[1] == ':') + { + outputSeparator = '\\'; + } + } + var levelsBack = 0; + var segmentStartPos = i; + for (; i <= fileName.Length; i++) + { + if (i == fileName.Length || fileName[i] == '/' || fileName[i] == '\\') + { + var segmentLength = i - segmentStartPos; + switch (segmentLength) + { + case 0: + // ignore empty segment (if not in web mode) + if (isWeb) + { + result.Append(outputSeparator); + } + break; + case 1: + // ignore /./ segment, but append other one-letter segments + if (fileName[segmentStartPos] != '.') + { + if (result.Length > 0) + result.Append(outputSeparator); + result.Append(fileName[segmentStartPos]); + } + break; + case 2: + if (fileName[segmentStartPos] == '.' && fileName[segmentStartPos + 1] == '.') + { + // remove previous segment + int j; + for (j = result.Length - 1; j >= 0 && result[j] != outputSeparator; j--) + { + } + if (j > 0) + { + result.Length = j; + } + else if (isAbsoluteUnixPath) + { + result.Length = 0; + } + else if (isRelative) + { + if (result.Length == 0) + levelsBack++; + else + result.Length = 0; + } + break; + } + else + { + // append normal segment + goto default; + } + default: + if (result.Length > 0) + result.Append(outputSeparator); + result.Append(fileName, segmentStartPos, segmentLength); + break; + } + segmentStartPos = i + 1; // remember start position for next segment + } + } + if (isWeb == false) + { + if (isRelative) + { + for (var j = 0; j < levelsBack; j++) + { + result.Insert(0, ".." + outputSeparator); + } + } + if (result.Length > 0 && result[result.Length - 1] == outputSeparator) + { + result.Length -= 1; + } + if (isAbsoluteUnixPath) + { + result.Insert(0, '/'); + } + if (result.Length == 2 && result[1] == ':') + { + result.Append(outputSeparator); + } + if (result.Length == 0) + return "."; + } + return result.ToString(); + } + + static bool IsUNCPath(string fileName) + { + return fileName.Length > 2 + && (fileName[0] == '\\' || fileName[0] == '/') + && (fileName[1] == '\\' || fileName[1] == '/'); + } + + public static bool IsEqualFileName(string fileName1, string fileName2) + { + return string.Equals(NormalizePath(fileName1), + NormalizePath(fileName2), + StringComparison.OrdinalIgnoreCase); + } + + public static bool IsBaseDirectory(string baseDirectory, string testDirectory) + { + if (baseDirectory == null || testDirectory == null) + return false; + baseDirectory = NormalizePath(baseDirectory); + if (baseDirectory == "." || baseDirectory == "") + return !Path.IsPathRooted(testDirectory); + baseDirectory = AddTrailingSeparator(baseDirectory); + testDirectory = AddTrailingSeparator(NormalizePath(testDirectory)); + + return testDirectory.StartsWith(baseDirectory, StringComparison.OrdinalIgnoreCase); + } + + static string AddTrailingSeparator(string input) + { + if (string.IsNullOrEmpty(input)) + return input; + if (input[input.Length - 1] == Path.DirectorySeparatorChar || input[input.Length - 1] == Path.AltDirectorySeparatorChar) + return input; + else + return input + GetSeparatorForPath(input).ToString(); + } + + static char GetSeparatorForPath(string input) + { + if (input.Length > 2 && input[1] == ':' || IsUNCPath(input)) + return '\\'; + return '/'; + } + + readonly static char[] separators = { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }; + + /// + /// Converts a given absolute path and a given base path to a path that leads + /// from the base path to the absoulte path. (as a relative path) + /// + public static string GetRelativePath(string baseDirectoryPath, string absPath) + { + if (string.IsNullOrEmpty(baseDirectoryPath)) + { + return absPath; + } + + baseDirectoryPath = NormalizePath(baseDirectoryPath); + absPath = NormalizePath(absPath); + + var bPath = baseDirectoryPath != "." ? baseDirectoryPath.TrimEnd(separators).Split(separators) : new string[0]; + var aPath = absPath != "." ? absPath.TrimEnd(separators).Split(separators) : new string[0]; + var indx = 0; + for (; indx < Math.Min(bPath.Length, aPath.Length); ++indx) + { + if (!bPath[indx].Equals(aPath[indx], StringComparison.OrdinalIgnoreCase)) + break; + } + + if (indx == 0 && (Path.IsPathRooted(baseDirectoryPath) || Path.IsPathRooted(absPath))) + { + return absPath; + } + + if (indx == bPath.Length && indx == aPath.Length) + { + return "."; + } + var erg = new StringBuilder(); + for (var i = indx; i < bPath.Length; ++i) + { + erg.Append(".."); + erg.Append(Path.DirectorySeparatorChar); + } + erg.Append(String.Join(Path.DirectorySeparatorChar.ToString(), aPath, indx, aPath.Length - indx)); + if (erg[erg.Length - 1] == Path.DirectorySeparatorChar) + erg.Length -= 1; + return erg.ToString(); + } + + public static string TrimPath(string path, int max_chars) + { + const char ellipsis = '\u2026'; // HORIZONTAL ELLIPSIS + const int ellipsisLength = 2; + + if (path == null || path.Length <= max_chars) + return path; + var sep = Path.DirectorySeparatorChar; + if (path.IndexOf(Path.AltDirectorySeparatorChar) >= 0 && path.IndexOf(Path.DirectorySeparatorChar) < 0) + { + sep = Path.AltDirectorySeparatorChar; + } + var parts = path.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); + var len = ellipsisLength; // For initial ellipsis + var index = parts.Length; + // From the end of the path, fit as many parts as possible: + while (index > 1 && len + parts[index - 1].Length < max_chars) + { + len += parts[index - 1].Length + 1; + index--; + } + + var result = new StringBuilder(); + result.Append(ellipsis); + // If there's 5 chars left, partially fit another part: + if (index > 1 && len + 5 <= max_chars) + { + if (index == 2 && parts[0].Length <= ellipsisLength) + { + // If the partial part is part #1, + // and part #0 is as short as the ellipsis + // (e.g. just a drive letter), use part #0 + // instead of the ellipsis. + result.Clear(); + result.Append(parts[0]); + } + result.Append(sep); + result.Append(parts[index - 1], 0, max_chars - len - 3); + result.Append(ellipsis); + } + while (index < parts.Length) + { + result.Append(sep); + result.Append(parts[index]); + index++; + } + return result.ToString(); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/GraphVizGraph.cs b/src/ICSharpCode.Decompiler/Util/GraphVizGraph.cs new file mode 100644 index 0000000..cd93cce --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/GraphVizGraph.cs @@ -0,0 +1,231 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Text.RegularExpressions; + +#pragma warning disable CS0649 // only default value. + +namespace ICSharpCode.Decompiler.Util +{ +#if DEBUG + /// + /// GraphViz graph. + /// + sealed class GraphVizGraph + { + List nodes = new List(); + List edges = new List(); + + public string rankdir; + public string Title; + + public void AddEdge(GraphVizEdge edge) + { + edges.Add(edge); + } + + public void AddNode(GraphVizNode node) + { + nodes.Add(node); + } + + public void Save(string fileName) + { + using (var writer = new StreamWriter(fileName)) + Save(writer); + } + + public void Show() + { + Show(null); + } + + public void Show(string name) + { + if (name == null) + name = Title; + if (name != null) + foreach (var c in Path.GetInvalidFileNameChars()) + name = name.Replace(c, '-'); + var fileName = name != null ? Path.Combine(Path.GetTempPath(), name) : Path.GetTempFileName(); + Save(fileName + ".gv"); + Process.Start("dot", "\"" + fileName + ".gv\" -Tpng -o \"" + fileName + ".png\"").WaitForExit(); + Process.Start(fileName + ".png"); + } + + static string Escape(string text) + { + if (Regex.IsMatch(text, @"^[\w\d]+$")) + { + return text; + } + else + { + return "\"" + text.Replace("\\", "\\\\").Replace("\r", "").Replace("\n", "\\n").Replace("\"", "\\\"") + "\""; + } + } + + static void WriteGraphAttribute(TextWriter writer, string name, string value) + { + if (value != null) + writer.WriteLine("{0}={1};", name, Escape(value)); + } + + internal static void WriteAttribute(TextWriter writer, string name, double? value, ref bool isFirst) + { + if (value != null) + { + WriteAttribute(writer, name, value.Value.ToString(CultureInfo.InvariantCulture), ref isFirst); + } + } + + internal static void WriteAttribute(TextWriter writer, string name, bool? value, ref bool isFirst) + { + if (value != null) + { + WriteAttribute(writer, name, value.Value ? "true" : "false", ref isFirst); + } + } + + internal static void WriteAttribute(TextWriter writer, string name, string value, ref bool isFirst) + { + if (value != null) + { + if (isFirst) + isFirst = false; + else + writer.Write(','); + writer.Write("{0}={1}", name, Escape(value)); + } + } + + public void Save(TextWriter writer) + { + if (writer == null) + throw new ArgumentNullException(nameof(writer)); + writer.WriteLine("digraph G {"); + writer.WriteLine("node [fontsize = 16];"); + WriteGraphAttribute(writer, "rankdir", rankdir); + foreach (var node in nodes) + { + node.Save(writer); + } + foreach (var edge in edges) + { + edge.Save(writer); + } + writer.WriteLine("}"); + } + } + + sealed class GraphVizEdge + { + public readonly string Source, Target; + + /// edge stroke color + public string color; + /// use edge to affect node ranking + public bool? constraint; + + public string label; + + public string style; + + /// point size of label + public int? fontsize; + + public GraphVizEdge(string source, string target) + { + if (source == null) + throw new ArgumentNullException(nameof(source)); + if (target == null) + throw new ArgumentNullException(nameof(target)); + this.Source = source; + this.Target = target; + } + + public GraphVizEdge(int source, int target) + { + this.Source = source.ToString(CultureInfo.InvariantCulture); + this.Target = target.ToString(CultureInfo.InvariantCulture); + } + + public void Save(TextWriter writer) + { + writer.Write("{0} -> {1} [", Source, Target); + var isFirst = true; + GraphVizGraph.WriteAttribute(writer, "label", label, ref isFirst); + GraphVizGraph.WriteAttribute(writer, "style", style, ref isFirst); + GraphVizGraph.WriteAttribute(writer, "fontsize", fontsize, ref isFirst); + GraphVizGraph.WriteAttribute(writer, "color", color, ref isFirst); + GraphVizGraph.WriteAttribute(writer, "constraint", constraint, ref isFirst); + writer.WriteLine("];"); + } + } + + sealed class GraphVizNode + { + public readonly string ID; + public string label; + + public string labelloc; + + /// point size of label + public int? fontsize; + + /// minimum height in inches + public double? height; + + /// space around label + public string margin; + + /// node shape + public string shape; + + public GraphVizNode(string id) + { + if (id == null) + throw new ArgumentNullException(nameof(id)); + this.ID = id; + } + + public GraphVizNode(int id) + { + this.ID = id.ToString(CultureInfo.InvariantCulture); + } + + public void Save(TextWriter writer) + { + writer.Write(ID); + writer.Write(" ["); + var isFirst = true; + GraphVizGraph.WriteAttribute(writer, "label", label, ref isFirst); + GraphVizGraph.WriteAttribute(writer, "labelloc", labelloc, ref isFirst); + GraphVizGraph.WriteAttribute(writer, "fontsize", fontsize, ref isFirst); + GraphVizGraph.WriteAttribute(writer, "margin", margin, ref isFirst); + GraphVizGraph.WriteAttribute(writer, "shape", shape, ref isFirst); + writer.WriteLine("];"); + } + } +#endif +} diff --git a/src/ICSharpCode.Decompiler/Util/Interval.cs b/src/ICSharpCode.Decompiler/Util/Interval.cs new file mode 100644 index 0000000..d41635d --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/Interval.cs @@ -0,0 +1,310 @@ +// Copyright (c) 2016 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.Util +{ + /// + /// Represents a half-closed interval. + /// The start position is inclusive; but the end position is exclusive. + /// + /// + /// Start <= unchecked(End - 1): normal interval + /// Start == End: empty interval + /// Special case: Start == End == int.MinValue: interval containing all integers, not an empty interval! + /// + public struct Interval : IEquatable + { + /// + /// Gets the inclusive start of the interval. + /// + public readonly int Start; + + /// + /// Gets the exclusive end of the interval. + /// + /// + /// Note that an End of int.MinValue is a special case, and stands + /// for an actual End of int.MaxValue+1. + /// If possible, prefer using InclusiveEnd for comparisons, as that does not have an overflow problem. + /// + public readonly int End; + + /// + /// Creates a new interval. + /// + /// Start position (inclusive) + /// End position (exclusive). + /// Note that it is possible to create an interval that includes int.MaxValue + /// by using end==int.MaxValue+1==int.MinValue. + public Interval(int start, int end) + { + if (!(start <= unchecked(end - 1) || start == end)) + throw new ArgumentException("The end must be after the start", nameof(end)); + this.Start = start; + this.End = end; + } + + /// + /// Gets the inclusive end of the interval. (End - 1) + /// For empty intervals, this returns Start - 1. + /// + /// + /// Because there is no empty interval at int.MinValue, + /// (Start==End==int.MinValue is a special case referring to [int.MinValue..int.MaxValue]), + /// integer overflow is not a problem here. + /// + public int InclusiveEnd { + get { + return unchecked(End - 1); + } + } + + public bool IsEmpty { + get { + return Start > InclusiveEnd; + } + } + + public bool Contains(int val) + { + // Use 'val <= InclusiveEnd' instead of 'val < End' to allow intervals to include int.MaxValue. + return Start <= val && val <= InclusiveEnd; + } + + /// + /// Calculates the intersection between this interval and the other interval. + /// + public Interval Intersect(Interval other) + { + var start = Math.Max(this.Start, other.Start); + var inclusiveEnd = Math.Min(this.InclusiveEnd, other.InclusiveEnd); + if (start <= inclusiveEnd) + return new Interval(start, unchecked(inclusiveEnd + 1)); + else + return default(Interval); + } + + public override string ToString() + { + if (End == int.MinValue) + return string.Format("[{0}..int.MaxValue]", Start); + else + return string.Format("[{0}..{1})", Start, End); + } + + #region Equals and GetHashCode implementation + public override bool Equals(object obj) + { + return (obj is Interval) && Equals((Interval)obj); + } + + public bool Equals(Interval other) + { + return this.Start == other.Start && this.End == other.End; + } + + public override int GetHashCode() + { + return Start ^ End ^ (End << 7); + } + + public static bool operator ==(Interval lhs, Interval rhs) + { + return lhs.Equals(rhs); + } + + public static bool operator !=(Interval lhs, Interval rhs) + { + return !(lhs == rhs); + } + #endregion + } + + /// + /// Represents a half-closed interval. + /// The start position is inclusive; but the end position is exclusive. + /// + /// + /// Start <= unchecked(End - 1): normal interval + /// Start == End: empty interval + /// Special case: Start == End == long.MinValue: interval containing all integers, not an empty interval! + /// + public struct LongInterval : IEquatable + { + /// + /// Gets the inclusive start of the interval. + /// + public readonly long Start; + + /// + /// Gets the exclusive end of the interval. + /// + /// + /// Note that an End of long.MinValue is a special case, and stands + /// for an actual End of long.MaxValue+1. + /// If possible, prefer using InclusiveEnd for comparisons, as that does not have an overflow problem. + /// + public readonly long End; + + /// + /// Creates a new interval. + /// + /// Start position (inclusive) + /// End position (exclusive). + /// Note that it is possible to create an interval that includes long.MaxValue + /// by using end==long.MaxValue+1==long.MinValue. + /// + /// This method can be used to create an empty interval by specifying start==end, + /// however this is error-prone due to the special case of + /// start==end==long.MinValue being interpreted as the full interval [long.MinValue,long.MaxValue]. + /// + public LongInterval(long start, long end) + { + if (!(start <= unchecked(end - 1) || start == end)) + throw new ArgumentException("The end must be after the start", nameof(end)); + this.Start = start; + this.End = end; + } + + /// + /// Creates a new interval from start to end. + /// Unlike the constructor where the end position is exclusive, + /// this method interprets the end position as inclusive. + /// + /// This method cannot be used to construct an empty interval. + /// + public static LongInterval Inclusive(long start, long inclusiveEnd) + { + if (!(start <= inclusiveEnd)) + throw new ArgumentException(); + return new LongInterval(start, unchecked(inclusiveEnd + 1)); + } + + /// + /// Gets the inclusive end of the interval. (End - 1) + /// For empty intervals, this returns Start - 1. + /// + /// + /// Because there is no empty interval at int.MinValue, + /// (Start==End==int.MinValue is a special case referring to [int.MinValue..int.MaxValue]), + /// integer overflow is not a problem here. + /// + public long InclusiveEnd { + get { + return unchecked(End - 1); + } + } + + public bool IsEmpty { + get { + return Start > InclusiveEnd; + } + } + + public bool Contains(long val) + { + // Use 'val <= InclusiveEnd' instead of 'val < End' to allow intervals to include long.MaxValue. + return Start <= val && val <= InclusiveEnd; + } + + /// + /// Calculates the intersection between this interval and the other interval. + /// + public LongInterval Intersect(LongInterval other) + { + var start = Math.Max(this.Start, other.Start); + var inclusiveEnd = Math.Min(this.InclusiveEnd, other.InclusiveEnd); + if (start <= inclusiveEnd) + return new LongInterval(start, unchecked(inclusiveEnd + 1)); + else + return default(LongInterval); + } + + /// + /// Returns an enumerator over all values in this interval. + /// + public IEnumerable Range() + { + if (End == long.MinValue) + { + var i = Start; + while (true) + { + yield return i; + if (i == long.MaxValue) + break; + i++; + } + } + else + { + for (var i = Start; i < End; i++) + yield return i; + } + } + + public override string ToString() + { + if (End == long.MinValue) + { + if (Start == long.MinValue) + return string.Format("[long.MinValue..long.MaxValue]", End); + else + return string.Format("[{0}..long.MaxValue]", Start); + } + else if (Start == long.MinValue) + { + return string.Format("[long.MinValue..{0})", End); + } + else + { + return string.Format("[{0}..{1})", Start, End); + } + } + + #region Equals and GetHashCode implementation + public override bool Equals(object obj) + { + return (obj is LongInterval) && Equals((LongInterval)obj); + } + + public bool Equals(LongInterval other) + { + return this.Start == other.Start && this.End == other.End; + } + + public override int GetHashCode() + { + return (Start ^ End ^ (End << 7)).GetHashCode(); + } + + public static bool operator ==(LongInterval lhs, LongInterval rhs) + { + return lhs.Equals(rhs); + } + + public static bool operator !=(LongInterval lhs, LongInterval rhs) + { + return !(lhs == rhs); + } + #endregion + } +} diff --git a/src/ICSharpCode.Decompiler/Util/KeyComparer.cs b/src/ICSharpCode.Decompiler/Util/KeyComparer.cs new file mode 100644 index 0000000..7cd6d70 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/KeyComparer.cs @@ -0,0 +1,86 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.Util +{ + public static class KeyComparer + { + public static KeyComparer Create(Func keySelector) + { + return new KeyComparer(keySelector, Comparer.Default, EqualityComparer.Default); + } + + public static KeyComparer Create(Func keySelector, IComparer comparer, IEqualityComparer equalityComparer) + { + return new KeyComparer(keySelector, comparer, equalityComparer); + } + + public static IComparer Create(Func keySelector, IComparer comparer) + { + return new KeyComparer(keySelector, comparer, EqualityComparer.Default); + } + + public static IEqualityComparer Create(Func keySelector, IEqualityComparer equalityComparer) + { + return new KeyComparer(keySelector, Comparer.Default, equalityComparer); + } + + public static void SortBy(this List list, Func keySelector) + { + list.Sort(Create(keySelector)); + } + } + + public class KeyComparer : IComparer, IEqualityComparer + { + readonly Func keySelector; + readonly IComparer keyComparer; + readonly IEqualityComparer keyEqualityComparer; + + public KeyComparer(Func keySelector, IComparer keyComparer, IEqualityComparer keyEqualityComparer) + { + if (keySelector == null) + throw new ArgumentNullException(nameof(keySelector)); + if (keyComparer == null) + throw new ArgumentNullException(nameof(keyComparer)); + if (keyEqualityComparer == null) + throw new ArgumentNullException(nameof(keyEqualityComparer)); + this.keySelector = keySelector; + this.keyComparer = keyComparer; + this.keyEqualityComparer = keyEqualityComparer; + } + + public int Compare(TElement x, TElement y) + { + return keyComparer.Compare(keySelector(x), keySelector(y)); + } + + public bool Equals(TElement x, TElement y) + { + return keyEqualityComparer.Equals(keySelector(x), keySelector(y)); + } + + public int GetHashCode(TElement obj) + { + return keyEqualityComparer.GetHashCode(keySelector(obj)); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/LazyInit.cs b/src/ICSharpCode.Decompiler/Util/LazyInit.cs new file mode 100644 index 0000000..8017a03 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/LazyInit.cs @@ -0,0 +1,41 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Threading; + +namespace ICSharpCode.Decompiler.Util +{ + public static class LazyInit + { + public static T VolatileRead(ref T location) where T : class + { + return Volatile.Read(ref location); + } + + /// + /// Atomically performs the following operation: + /// - If target is null: stores newValue in target and returns newValue. + /// - If target is not null: returns target. + /// + public static T GetOrSet(ref T target, T newValue) where T : class + { + var oldValue = Interlocked.CompareExchange(ref target, newValue, null); + return oldValue ?? newValue; + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/LongDict.cs b/src/ICSharpCode.Decompiler/Util/LongDict.cs new file mode 100644 index 0000000..48a6c89 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/LongDict.cs @@ -0,0 +1,102 @@ +// Copyright (c) 2017 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections; +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.Util +{ + static class LongDict + { + public static LongDict Create(IEnumerable<(LongSet, T)> entries) + { + return new LongDict(entries); + } + + internal static readonly KeyComparer StartComparer = KeyComparer.Create((LongInterval i) => i.Start); + } + + /// + /// An immutable mapping from keys of type long to values of type T. + /// + struct LongDict : IEnumerable> + { + readonly LongInterval[] keys; + readonly T[] values; + + /// + /// Creates a new LongDict from the given entries. + /// If there are multiple entries for the same long key, + /// the resulting LongDict will store the value from the first entry. + /// + public LongDict(IEnumerable<(LongSet, T)> entries) + { + var available = LongSet.Universe; + var keys = new List(); + var values = new List(); + foreach (var (key, val) in entries) + { + foreach (var interval in key.IntersectWith(available).Intervals) + { + keys.Add(interval); + values.Add(val); + } + available = available.ExceptWith(key); + } + this.keys = keys.ToArray(); + this.values = values.ToArray(); + Array.Sort(this.keys, this.values, LongDict.StartComparer); + } + + public bool TryGetValue(long key, out T value) + { + var pos = Array.BinarySearch(this.keys, new LongInterval(key, key), LongDict.StartComparer); + // If the element isn't found, BinarySearch returns the complement of "insertion position". + // We use this to find the previous element (if there wasn't any exact match). + if (pos < 0) + pos = ~pos - 1; + if (pos >= 0 && this.keys[pos].Contains(key)) + { + value = this.values[pos]; + return true; + } + value = default(T); + return false; + } + + public T GetOrDefault(long key) + { + TryGetValue(key, out var val); + return val; + } + + public IEnumerator> GetEnumerator() + { + for (var i = 0; i < this.keys.Length; ++i) + { + yield return new KeyValuePair(this.keys[i], this.values[i]); + } + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/LongSet.cs b/src/ICSharpCode.Decompiler/Util/LongSet.cs new file mode 100644 index 0000000..a33ac2a --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/LongSet.cs @@ -0,0 +1,382 @@ +// Copyright (c) 2016 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Linq; + +namespace ICSharpCode.Decompiler.Util +{ + /// + /// An immutable set of longs, that is implemented as a list of intervals. + /// + public struct LongSet : IEquatable + { + /// + /// The intervals in this set of longs. + /// + /// + /// Invariant: the intervals in this array are non-empty, non-overlapping, non-touching, and sorted. + /// + /// This invariant ensures every LongSet is always in a normalized representation. + /// + public readonly ImmutableArray Intervals; + + private LongSet(ImmutableArray intervals) + { + this.Intervals = intervals; +#if DEBUG + // Check invariant + var minValue = long.MinValue; + for (var i = 0; i < intervals.Length; i++) + { + Debug.Assert(!intervals[i].IsEmpty); + Debug.Assert(minValue <= intervals[i].Start); + if (intervals[i].InclusiveEnd == long.MaxValue - 1 || intervals[i].InclusiveEnd == long.MaxValue) + { + // An inclusive end of long.MaxValue-1 or long.MaxValue means (after the gap of 1 element), + // there isn't any room for more non-empty intervals. + Debug.Assert(i == intervals.Length - 1); + } + else + { + minValue = checked(intervals[i].End + 1); // enforce least 1 gap between intervals + } + } +#endif + } + + /// + /// Create a new LongSet that contains a single value. + /// + public LongSet(long value) + : this(ImmutableArray.Create(LongInterval.Inclusive(value, value))) + { + } + + /// + /// Create a new LongSet that contains the values from the interval. + /// + public LongSet(LongInterval interval) + : this(interval.IsEmpty ? Empty.Intervals : ImmutableArray.Create(interval)) + { + } + + /// + /// Creates a new LongSet the contains the values from the specified intervals. + /// + public LongSet(IEnumerable intervals) + : this(MergeOverlapping(intervals.Where(i => !i.IsEmpty).OrderBy(i => i.Start)).ToImmutableArray()) + { + } + + /// + /// The empty LongSet. + /// + public static readonly LongSet Empty = new LongSet(ImmutableArray.Create()); + + /// + /// The LongSet that contains all possible long values. + /// + public static readonly LongSet Universe = new LongSet(LongInterval.Inclusive(long.MinValue, long.MaxValue)); + + public bool IsEmpty { + get { return Intervals.IsEmpty; } + } + + /// + /// Gets the number of values in this LongSet. + /// Note: for LongSet.Universe, the number of values does not fit into ulong. + /// Instead, this property returns the off-by-one value ulong.MaxValue to avoid overflow. + /// + public ulong Count() + { + unchecked + { + ulong count = 0; + foreach (var interval in Intervals) + { + count += (ulong)(interval.End - interval.Start); + } + if (count == 0 && !Intervals.IsEmpty) + return ulong.MaxValue; + else + return count; + } + } + + + IEnumerable DoIntersectWith(LongSet other) + { + var enumA = this.Intervals.GetEnumerator(); + var enumB = other.Intervals.GetEnumerator(); + var moreA = enumA.MoveNext(); + var moreB = enumB.MoveNext(); + while (moreA && moreB) + { + var a = enumA.Current; + var b = enumB.Current; + var intersection = a.Intersect(b); + if (!intersection.IsEmpty) + { + yield return intersection; + } + if (a.InclusiveEnd < b.InclusiveEnd) + { + moreA = enumA.MoveNext(); + } + else + { + moreB = enumB.MoveNext(); + } + } + } + + public bool Overlaps(LongSet other) + { + return DoIntersectWith(other).Any(); + } + + public LongSet IntersectWith(LongSet other) + { + return new LongSet(DoIntersectWith(other).ToImmutableArray()); + } + + /// + /// Given an enumerable of non-empty intervals sorted by the starting position, + /// merges overlapping or touching intervals to create a valid interval array for LongSet. + /// + static IEnumerable MergeOverlapping(IEnumerable input) + { + var start = long.MinValue; + var end = long.MinValue; + var empty = true; + foreach (var element in input) + { + Debug.Assert(start <= element.Start); + Debug.Assert(!element.IsEmpty); + + if (!empty && element.Start <= end) + { + // element overlaps or touches [start, end), so combine the intervals: + if (element.End == long.MinValue) + { + // special case: element goes all the way up to long.MaxValue inclusive + end = long.MinValue; + } + else + { + end = Math.Max(end, element.End); + } + } + else + { + // flush existing interval: + if (!empty) + { + yield return new LongInterval(start, end); + } + else + { + empty = false; + } + start = element.Start; + end = element.End; + } + if (end == long.MinValue) + { + // special case: element goes all the way up to long.MaxValue inclusive + // all further intervals in the input must be contained in [start, end), + // so ignore them (and avoid trouble due to the overflow in `end`). + break; + } + } + if (!empty) + { + yield return new LongInterval(start, end); + } + } + + public LongSet UnionWith(LongSet other) + { + var mergedIntervals = this.Intervals.Merge(other.Intervals, (a, b) => a.Start.CompareTo(b.Start)); + return new LongSet(MergeOverlapping(mergedIntervals).ToImmutableArray()); + } + + /// + /// Creates a new LongSet where val is added to each element of this LongSet. + /// + public LongSet AddOffset(long val) + { + if (val == 0) + { + return this; + } + var newIntervals = new List(Intervals.Length + 1); + foreach (var element in Intervals) + { + var newStart = unchecked(element.Start + val); + var newInclusiveEnd = unchecked(element.InclusiveEnd + val); + if (newStart <= newInclusiveEnd) + { + newIntervals.Add(LongInterval.Inclusive(newStart, newInclusiveEnd)); + } + else + { + // interval got split by integer overflow + newIntervals.Add(LongInterval.Inclusive(newStart, long.MaxValue)); + newIntervals.Add(LongInterval.Inclusive(long.MinValue, newInclusiveEnd)); + } + } + newIntervals.Sort((a, b) => a.Start.CompareTo(b.Start)); + return new LongSet(MergeOverlapping(newIntervals).ToImmutableArray()); + } + + /// + /// Creates a new set that contains all values that are in this, but not in other. + /// + public LongSet ExceptWith(LongSet other) + { + return IntersectWith(other.Invert()); + } + + /// + /// Creates a new LongSet that contains all elements not contained in this LongSet. + /// + public LongSet Invert() + { + // The loop below assumes a non-empty LongSet, so handle the empty case specially. + if (IsEmpty) + { + return Universe; + } + var newIntervals = new List(Intervals.Length + 1); + var prevEnd = long.MinValue; // previous exclusive end + foreach (var interval in Intervals) + { + if (interval.Start > prevEnd) + { + newIntervals.Add(new LongInterval(prevEnd, interval.Start)); + } + prevEnd = interval.End; + } + // create a final interval up to long.MaxValue inclusive + if (prevEnd != long.MinValue) + { + newIntervals.Add(new LongInterval(prevEnd, long.MinValue)); + } + return new LongSet(newIntervals.ToImmutableArray()); + } + + /// + /// Gets whether this set is a subset of other, or equal. + /// + public bool IsSubsetOf(LongSet other) + { + // TODO: optimize IsSubsetOf -- there's no need to build a temporary set + return this.UnionWith(other).SetEquals(other); + } + + /// + /// Gets whether this set is a superset of other, or equal. + /// + public bool IsSupersetOf(LongSet other) + { + return other.IsSubsetOf(this); + } + + public bool IsProperSubsetOf(LongSet other) + { + return IsSubsetOf(other) && !SetEquals(other); + } + + public bool IsProperSupersetOf(LongSet other) + { + return IsSupersetOf(other) && !SetEquals(other); + } + + public bool Contains(long val) + { + var index = upper_bound(val); + return index > 0 && Intervals[index - 1].Contains(val); + } + + internal int upper_bound(long val) + { + int min = 0, max = Intervals.Length - 1; + while (max >= min) + { + var m = min + (max - min) / 2; + var i = Intervals[m]; + if (val < i.Start) + { + max = m - 1; + continue; + } + if (val > i.End) + { + min = m + 1; + continue; + } + return m + 1; + } + return min; + } + + public IEnumerable Values { + get { return Intervals.SelectMany(i => i.Range()); } + } + + public override string ToString() + { + return string.Join(",", Intervals); + } + + #region Equals and GetHashCode implementation + public override bool Equals(object obj) + { + return obj is LongSet && SetEquals((LongSet)obj); + } + + public override int GetHashCode() + { + throw new NotImplementedException(); + } + + [Obsolete("Explicitly call SetEquals() instead.")] + public bool Equals(LongSet other) + { + return SetEquals(other); + } + + public bool SetEquals(LongSet other) + { + if (Intervals.Length != other.Intervals.Length) + return false; + for (var i = 0; i < Intervals.Length; i++) + { + if (Intervals[i] != other.Intervals[i]) + return false; + } + return true; + } + #endregion + } +} diff --git a/src/ICSharpCode.Decompiler/Util/MultiDictionary.cs b/src/ICSharpCode.Decompiler/Util/MultiDictionary.cs new file mode 100644 index 0000000..ec93a86 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/MultiDictionary.cs @@ -0,0 +1,151 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Linq; + +namespace ICSharpCode.Decompiler.Util +{ + /// + /// A dictionary that allows multiple pairs with the same key. + /// + public class MultiDictionary : ILookup + { + readonly Dictionary> dict; + + public MultiDictionary() + { + dict = new Dictionary>(); + } + + public MultiDictionary(IEqualityComparer comparer) + { + dict = new Dictionary>(comparer); + } + + public void Add(TKey key, TValue value) + { + List valueList; + if (!dict.TryGetValue(key, out valueList)) + { + valueList = new List(); + dict.Add(key, valueList); + } + valueList.Add(value); + } + + public bool Remove(TKey key, TValue value) + { + List valueList; + if (dict.TryGetValue(key, out valueList)) + { + if (valueList.Remove(value)) + { + if (valueList.Count == 0) + dict.Remove(key); + return true; + } + } + return false; + } + + /// + /// Removes all entries with the specified key. + /// + /// Returns true if at least one entry was removed. + public bool RemoveAll(TKey key) + { + return dict.Remove(key); + } + + public void Clear() + { + dict.Clear(); + } + + public IReadOnlyList this[TKey key] { + get { + if (dict.TryGetValue(key, out var list)) + return list; + else + return EmptyList.Instance; + } + } + + /// + /// Returns the number of different keys. + /// + public int Count { + get { return dict.Count; } + } + + public ICollection Keys { + get { return dict.Keys; } + } + + public IEnumerable Values { + get { return dict.Values.SelectMany(list => list); } + } + + IEnumerable ILookup.this[TKey key] { + get { return this[key]; } + } + + bool ILookup.Contains(TKey key) + { + return dict.ContainsKey(key); + } + + public IEnumerator> GetEnumerator() + { + foreach (var pair in dict) + yield return new Grouping(pair.Key, pair.Value); + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + sealed class Grouping : IGrouping + { + readonly TKey key; + readonly List values; + + public Grouping(TKey key, List values) + { + this.key = key; + this.values = values; + } + + public TKey Key { + get { return key; } + } + + public IEnumerator GetEnumerator() + { + return values.GetEnumerator(); + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return values.GetEnumerator(); + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/Platform.cs b/src/ICSharpCode.Decompiler/Util/Platform.cs new file mode 100644 index 0000000..b91a910 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/Platform.cs @@ -0,0 +1,41 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; + +namespace ICSharpCode.Decompiler.Util +{ + /// + /// Platform-specific code. + /// + public static class Platform + { + public static StringComparer FileNameComparer { + get { + switch (Environment.OSVersion.Platform) + { + case PlatformID.Unix: + case PlatformID.MacOSX: + return StringComparer.Ordinal; + default: + return StringComparer.OrdinalIgnoreCase; + } + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/ProjectedList.cs b/src/ICSharpCode.Decompiler/Util/ProjectedList.cs new file mode 100644 index 0000000..5661d2d --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/ProjectedList.cs @@ -0,0 +1,117 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.Util +{ + public sealed class ProjectedList : IReadOnlyList where TOutput : class + { + readonly IList input; + readonly Func projection; + readonly TOutput[] items; + + public ProjectedList(IList input, Func projection) + { + if (input == null) + throw new ArgumentNullException(nameof(input)); + if (projection == null) + throw new ArgumentNullException(nameof(projection)); + this.input = input; + this.projection = projection; + this.items = new TOutput[input.Count]; + } + + public TOutput this[int index] { + get { + var output = LazyInit.VolatileRead(ref items[index]); + if (output != null) + { + return output; + } + return LazyInit.GetOrSet(ref items[index], projection(input[index])); + } + } + + public int Count { + get { return items.Length; } + } + + public IEnumerator GetEnumerator() + { + for (var i = 0; i < this.Count; i++) + { + yield return this[i]; + } + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } + + public sealed class ProjectedList : IReadOnlyList where TOutput : class + { + readonly IList input; + readonly TContext context; + readonly Func projection; + readonly TOutput[] items; + + public ProjectedList(TContext context, IList input, Func projection) + { + if (input == null) + throw new ArgumentNullException(nameof(input)); + if (projection == null) + throw new ArgumentNullException(nameof(projection)); + this.input = input; + this.context = context; + this.projection = projection; + this.items = new TOutput[input.Count]; + } + + public TOutput this[int index] { + get { + var output = LazyInit.VolatileRead(ref items[index]); + if (output != null) + { + return output; + } + return LazyInit.GetOrSet(ref items[index], projection(context, input[index])); + } + } + + public int Count { + get { return items.Length; } + } + + public IEnumerator GetEnumerator() + { + for (var i = 0; i < this.Count; i++) + { + yield return this[i]; + } + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/ReferenceComparer.cs b/src/ICSharpCode.Decompiler/Util/ReferenceComparer.cs new file mode 100644 index 0000000..cb4485b --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/ReferenceComparer.cs @@ -0,0 +1,38 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; +using System.Runtime.CompilerServices; + +namespace ICSharpCode.Decompiler.Util +{ + public sealed class ReferenceComparer : IEqualityComparer + { + public readonly static ReferenceComparer Instance = new ReferenceComparer(); + + public new bool Equals(object x, object y) + { + return x == y; + } + + public int GetHashCode(object obj) + { + return RuntimeHelpers.GetHashCode(obj); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/ResXResourceWriter.cs b/src/ICSharpCode.Decompiler/Util/ResXResourceWriter.cs new file mode 100644 index 0000000..7df2343 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/ResXResourceWriter.cs @@ -0,0 +1,570 @@ +// Copyright (c) 2018 Daniel Grunwald +// This file is based on the Mono implementation of ResXResourceWriter. +// It is modified to add support for "ResourceSerializedObject" values. +// +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// +// Copyright (c) 2004-2005 Novell, Inc. +// +// Authors: +// Duncan Mak duncan@ximian.com +// Gonzalo Paniagua Javier gonzalo@ximian.com +// Peter Bartok pbartok@novell.com +// Gary Barnett gary.barnett.mono@gmail.com +// includes code by Mike Krüger and Lluis Sanchez + +using System; +using System.ComponentModel; +using System.IO; +using System.Runtime.Serialization.Formatters.Binary; +using System.Text; +using System.Xml; + +namespace ICSharpCode.Decompiler.Util +{ +#if INSIDE_SYSTEM_WEB + internal +#else + public +#endif + class ResXResourceWriter : IDisposable + { + #region Local Variables + private string filename; + private Stream stream; + private TextWriter textwriter; + private XmlTextWriter writer; + private bool written; + private string base_path; + #endregion // Local Variables + + #region Static Fields + public static readonly string BinSerializedObjectMimeType = "application/x-microsoft.net.object.binary.base64"; + public static readonly string ByteArraySerializedObjectMimeType = "application/x-microsoft.net.object.bytearray.base64"; + public static readonly string DefaultSerializedObjectMimeType = BinSerializedObjectMimeType; + public static readonly string ResMimeType = "text/microsoft-resx"; + public static readonly string ResourceSchema = schema; + public static readonly string SoapSerializedObjectMimeType = "application/x-microsoft.net.object.soap.base64"; + public static readonly string Version = "2.0"; + #endregion // Static Fields + + #region Constructors & Destructor + public ResXResourceWriter(Stream stream) + { + if (stream == null) + throw new ArgumentNullException(nameof(stream)); + + if (!stream.CanWrite) + throw new ArgumentException("stream is not writable.", nameof(stream)); + + this.stream = stream; + } + + public ResXResourceWriter(TextWriter textWriter) + { + if (textWriter == null) + throw new ArgumentNullException(nameof(textWriter)); + + this.textwriter = textWriter; + } + + public ResXResourceWriter(string fileName) + { + if (fileName == null) + throw new ArgumentNullException(nameof(fileName)); + + this.filename = fileName; + } + + ~ResXResourceWriter() + { + Dispose(false); + } + #endregion // Constructors & Destructor + + const string WinFormsAssemblyName = ", System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"; + const string ResXNullRefTypeName = "System.Resources.ResXNullRef" + WinFormsAssemblyName; + + void InitWriter() + { + if (filename != null) + stream = File.Open(filename, FileMode.Create); + if (textwriter == null) + textwriter = new StreamWriter(stream, Encoding.UTF8); + + writer = new XmlTextWriter(textwriter); + writer.Formatting = Formatting.Indented; + writer.WriteStartDocument(); + writer.WriteStartElement("root"); + writer.WriteRaw(schema); + WriteHeader("resmimetype", "text/microsoft-resx"); + WriteHeader("version", "1.3"); + WriteHeader("reader", "System.Resources.ResXResourceReader" + WinFormsAssemblyName); + WriteHeader("writer", "System.Resources.ResXResourceWriter" + WinFormsAssemblyName); + } + + void WriteHeader(string name, string value) + { + writer.WriteStartElement("resheader"); + writer.WriteAttributeString("name", name); + writer.WriteStartElement("value"); + writer.WriteString(value); + writer.WriteEndElement(); + writer.WriteEndElement(); + } + + void WriteNiceBase64(byte[] value, int offset, int length) + { + string b64; + StringBuilder sb; + int pos; + int inc; + string ins; + + b64 = Convert.ToBase64String(value, offset, length); + + // Wild guess; two extra newlines, and one newline/tab pair for every 80 chars + sb = new StringBuilder(b64, b64.Length + ((b64.Length + 160) / 80) * 3); + pos = 0; + inc = 80 + Environment.NewLine.Length + 1; + ins = Environment.NewLine + "\t"; + while (pos < sb.Length) + { + sb.Insert(pos, ins); + pos += inc; + } + sb.Insert(sb.Length, Environment.NewLine); + writer.WriteString(sb.ToString()); + } + + void WriteBytes(string name, Type type, byte[] value, int offset, int length, string comment) + { + writer.WriteStartElement("data"); + writer.WriteAttributeString("name", name); + + if (type != null) + { + writer.WriteAttributeString("type", type.AssemblyQualifiedName); + // byte[] should never get a mimetype, otherwise MS.NET won't be able + // to parse the data. + if (type != typeof(byte[])) + writer.WriteAttributeString("mimetype", ByteArraySerializedObjectMimeType); + writer.WriteStartElement("value"); + WriteNiceBase64(value, offset, length); + } + else + { + writer.WriteAttributeString("mimetype", BinSerializedObjectMimeType); + writer.WriteStartElement("value"); + writer.WriteBase64(value, offset, length); + } + + writer.WriteEndElement(); + + if (!(comment == null || comment.Equals(String.Empty))) + { + writer.WriteStartElement("comment"); + writer.WriteString(comment); + writer.WriteEndElement(); + } + + writer.WriteEndElement(); + } + + void WriteBytes(string name, Type type, byte[] value, string comment) + { + WriteBytes(name, type, value, 0, value.Length, comment); + } + + void WriteString(string name, string value) + { + WriteString(name, value, null); + } + void WriteString(string name, string value, string type) + { + WriteString(name, value, type, String.Empty); + } + void WriteString(string name, string value, string type, string comment) + { + writer.WriteStartElement("data"); + writer.WriteAttributeString("name", name); + if (type != null) + writer.WriteAttributeString("type", type); + writer.WriteStartElement("value"); + writer.WriteString(value); + writer.WriteEndElement(); + if (!(comment == null || comment.Equals(String.Empty))) + { + writer.WriteStartElement("comment"); + writer.WriteString(comment); + writer.WriteEndElement(); + } + writer.WriteEndElement(); + writer.WriteWhitespace("\n "); + } + + public void AddResource(string name, byte[] value) + { + if (name == null) + throw new ArgumentNullException(nameof(name)); + + if (value == null) + throw new ArgumentNullException(nameof(value)); + + if (written) + throw new InvalidOperationException("The resource is already generated."); + + if (writer == null) + InitWriter(); + + WriteBytes(name, value.GetType(), value, null); + } + + public void AddResource(string name, object value) + { + AddResource(name, value, String.Empty); + } + + private void AddResource(string name, object value, string comment) + { + if (value is string) + { + AddResource(name, (string)value, comment); + return; + } + + if (name == null) + throw new ArgumentNullException(nameof(name)); + + if (written) + throw new InvalidOperationException("The resource is already generated."); + + if (writer == null) + InitWriter(); + + if (value is byte[]) + { + WriteBytes(name, value.GetType(), (byte[])value, comment); + return; + } + if (value is ResourceSerializedObject rso) + { + var bytes = rso.GetBytes(); + WriteBytes(name, null, bytes, 0, bytes.Length, comment); + return; + } + + if (value == null) + { + // nulls written as ResXNullRef + WriteString(name, "", ResXNullRefTypeName, comment); + return; + } + + if (value != null && !value.GetType().IsSerializable) + throw new InvalidOperationException(String.Format("The element '{0}' of type '{1}' is not serializable.", name, value.GetType().Name)); + + var converter = TypeDescriptor.GetConverter(value); + + if (converter != null && converter.CanConvertTo(typeof(string)) && converter.CanConvertFrom(typeof(string))) + { + var str = (string)converter.ConvertToInvariantString(value); + WriteString(name, str, value.GetType().AssemblyQualifiedName, comment); + return; + } + + if (converter != null && converter.CanConvertTo(typeof(byte[])) && converter.CanConvertFrom(typeof(byte[]))) + { + var b = (byte[])converter.ConvertTo(value, typeof(byte[])); + WriteBytes(name, value.GetType(), b, comment); + return; + } + + var ms = new MemoryStream(); + var fmt = new BinaryFormatter(); + try + { + fmt.Serialize(ms, value); + } + catch (Exception e) + { + throw new InvalidOperationException("Cannot add a " + value.GetType() + + "because it cannot be serialized: " + + e.Message); + } + + WriteBytes(name, null, ms.GetBuffer(), 0, (int)ms.Length, comment); + ms.Close(); + } + + public void AddResource(string name, string value) + { + AddResource(name, value, string.Empty); + } + + private void AddResource(string name, string value, string comment) + { + if (name == null) + throw new ArgumentNullException(nameof(name)); + + if (value == null) + throw new ArgumentNullException(nameof(value)); + + if (written) + throw new InvalidOperationException("The resource is already generated."); + + if (writer == null) + InitWriter(); + + WriteString(name, value, null, comment); + } + + public void AddMetadata(string name, string value) + { + if (name == null) + throw new ArgumentNullException(nameof(name)); + + if (value == null) + throw new ArgumentNullException(nameof(value)); + + if (written) + throw new InvalidOperationException("The resource is already generated."); + + if (writer == null) + InitWriter(); + + writer.WriteStartElement("metadata"); + writer.WriteAttributeString("name", name); + writer.WriteAttributeString("xml:space", "preserve"); + + writer.WriteElementString("value", value); + + writer.WriteEndElement(); + } + + public void AddMetadata(string name, byte[] value) + { + if (name == null) + throw new ArgumentNullException(nameof(name)); + + if (value == null) + throw new ArgumentNullException(nameof(value)); + + if (written) + throw new InvalidOperationException("The resource is already generated."); + + if (writer == null) + InitWriter(); + + writer.WriteStartElement("metadata"); + writer.WriteAttributeString("name", name); + + writer.WriteAttributeString("type", value.GetType().AssemblyQualifiedName); + + writer.WriteStartElement("value"); + WriteNiceBase64(value, 0, value.Length); + writer.WriteEndElement(); + + writer.WriteEndElement(); + } + + public void AddMetadata(string name, object value) + { + if (value is string) + { + AddMetadata(name, (string)value); + return; + } + + if (value is byte[]) + { + AddMetadata(name, (byte[])value); + return; + } + + if (name == null) + throw new ArgumentNullException(nameof(name)); + + if (value == null) + throw new ArgumentNullException(nameof(value)); + + if (!value.GetType().IsSerializable) + throw new InvalidOperationException(String.Format("The element '{0}' of type '{1}' is not serializable.", name, value.GetType().Name)); + + if (written) + throw new InvalidOperationException("The resource is already generated."); + + if (writer == null) + InitWriter(); + + var type = value.GetType(); + + var converter = TypeDescriptor.GetConverter(value); + if (converter != null && converter.CanConvertTo(typeof(string)) && converter.CanConvertFrom(typeof(string))) + { + var str = (string)converter.ConvertToInvariantString(value); + writer.WriteStartElement("metadata"); + writer.WriteAttributeString("name", name); + if (type != null) + writer.WriteAttributeString("type", type.AssemblyQualifiedName); + writer.WriteStartElement("value"); + writer.WriteString(str); + writer.WriteEndElement(); + writer.WriteEndElement(); + writer.WriteWhitespace("\n "); + return; + } + + if (converter != null && converter.CanConvertTo(typeof(byte[])) && converter.CanConvertFrom(typeof(byte[]))) + { + var b = (byte[])converter.ConvertTo(value, typeof(byte[])); + writer.WriteStartElement("metadata"); + writer.WriteAttributeString("name", name); + + if (type != null) + { + writer.WriteAttributeString("type", type.AssemblyQualifiedName); + writer.WriteAttributeString("mimetype", ByteArraySerializedObjectMimeType); + writer.WriteStartElement("value"); + WriteNiceBase64(b, 0, b.Length); + } + else + { + writer.WriteAttributeString("mimetype", BinSerializedObjectMimeType); + writer.WriteStartElement("value"); + writer.WriteBase64(b, 0, b.Length); + } + + writer.WriteEndElement(); + writer.WriteEndElement(); + return; + } + + var ms = new MemoryStream(); + var fmt = new BinaryFormatter(); + try + { + fmt.Serialize(ms, value); + } + catch (Exception e) + { + throw new InvalidOperationException("Cannot add a " + value.GetType() + + "because it cannot be serialized: " + + e.Message); + } + + writer.WriteStartElement("metadata"); + writer.WriteAttributeString("name", name); + + if (type != null) + { + writer.WriteAttributeString("type", type.AssemblyQualifiedName); + writer.WriteAttributeString("mimetype", ByteArraySerializedObjectMimeType); + writer.WriteStartElement("value"); + WriteNiceBase64(ms.GetBuffer(), 0, ms.GetBuffer().Length); + } + else + { + writer.WriteAttributeString("mimetype", BinSerializedObjectMimeType); + writer.WriteStartElement("value"); + writer.WriteBase64(ms.GetBuffer(), 0, ms.GetBuffer().Length); + } + + writer.WriteEndElement(); + writer.WriteEndElement(); + ms.Close(); + } + + public void Close() + { + if (writer != null) + { + if (!written) + { + Generate(); + } + + writer.Close(); + stream = null; + filename = null; + textwriter = null; + } + } + + public virtual void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + public void Generate() + { + if (written) + throw new InvalidOperationException("The resource is already generated."); + + written = true; + writer.WriteEndElement(); + writer.Flush(); + } + + protected virtual void Dispose(bool disposing) + { + if (disposing) + Close(); + } + + static string schema = @" + + + + + + + + + + + + + + + + + + + + + + + + + + + +".Replace("'", "\"").Replace("\t", " "); + + #region Public Properties + public string BasePath { + get { return base_path; } + set { base_path = value; } + } + #endregion + } +} diff --git a/src/ICSharpCode.Decompiler/Util/ResourcesFile.cs b/src/ICSharpCode.Decompiler/Util/ResourcesFile.cs new file mode 100644 index 0000000..b472d8a --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/ResourcesFile.cs @@ -0,0 +1,571 @@ +// Copyright (c) 2018 Daniel Grunwald +// Based on the .NET Core ResourceReader; make available under the MIT license +// by the .NET Foundation. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Text; + +namespace ICSharpCode.Decompiler.Util +{ + /// + /// .resources file. + /// + public class ResourcesFile : IEnumerable>, IDisposable + { + sealed class MyBinaryReader : BinaryReader + { + public MyBinaryReader(Stream input, bool leaveOpen) : base(input, Encoding.UTF8, leaveOpen) + { + } + + // upgrade from protected to public visibility + public new int Read7BitEncodedInt() + { + return base.Read7BitEncodedInt(); + } + + public void Seek(long pos, SeekOrigin origin) + { + BaseStream.Seek(pos, origin); + } + } + + enum ResourceTypeCode + { + Null = 0, + String = 1, + Boolean = 2, + Char = 3, + Byte = 4, + SByte = 5, + Int16 = 6, + UInt16 = 7, + Int32 = 8, + UInt32 = 9, + Int64 = 10, + UInt64 = 11, + Single = 12, + Double = 13, + Decimal = 14, + DateTime = 0xF, + TimeSpan = 0x10, + LastPrimitive = 0x10, + ByteArray = 0x20, + Stream = 33, + StartOfUserTypes = 0x40 + } + + /// Holds the number used to identify resource files. + public const int MagicNumber = unchecked((int)0xBEEFCACE); + const int ResourceSetVersion = 2; + + readonly MyBinaryReader reader; + readonly int version; + readonly int numResources; + readonly string[] typeTable; + readonly int[] namePositions; + readonly long fileStartPosition; + readonly long nameSectionPosition; + readonly long dataSectionPosition; + long[] startPositions; + + /// + /// Creates a new ResourcesFile. + /// + /// Input stream. + /// Whether the stream should be help open when the ResourcesFile is disposed. + /// + /// The stream is must be held open while the ResourcesFile is in use. + /// The stream must be seekable; any operation using the ResourcesFile will end up seeking the stream. + /// + public ResourcesFile(Stream stream, bool leaveOpen = true) + { + fileStartPosition = stream.Position; + reader = new MyBinaryReader(stream, leaveOpen); + + const string ResourcesHeaderCorrupted = "Resources header corrupted."; + + // Read ResourceManager header + // Check for magic number + var magicNum = reader.ReadInt32(); + if (magicNum != MagicNumber) + throw new BadImageFormatException("Not a .resources file - invalid magic number"); + // Assuming this is ResourceManager header V1 or greater, hopefully + // after the version number there is a number of bytes to skip + // to bypass the rest of the ResMgr header. For V2 or greater, we + // use this to skip to the end of the header + var resMgrHeaderVersion = reader.ReadInt32(); + var numBytesToSkip = reader.ReadInt32(); + if (numBytesToSkip < 0 || resMgrHeaderVersion < 0) + { + throw new BadImageFormatException(ResourcesHeaderCorrupted); + } + if (resMgrHeaderVersion > 1) + { + reader.BaseStream.Seek(numBytesToSkip, SeekOrigin.Current); + } + else + { + // We don't care about numBytesToSkip; read the rest of the header + + // readerType: + reader.ReadString(); + // resourceSetType: + reader.ReadString(); + } + + // Read RuntimeResourceSet header + // Do file version check + version = reader.ReadInt32(); + if (version != ResourceSetVersion && version != 1) + throw new BadImageFormatException($"Unsupported resource set version: {version}"); + + numResources = reader.ReadInt32(); + if (numResources < 0) + { + throw new BadImageFormatException(ResourcesHeaderCorrupted); + } + + // Read type positions into type positions array. + // But delay initialize the type table. + var numTypes = reader.ReadInt32(); + if (numTypes < 0) + { + throw new BadImageFormatException(ResourcesHeaderCorrupted); + } + typeTable = new string[numTypes]; + for (var i = 0; i < numTypes; i++) + { + typeTable[i] = reader.ReadString(); + } + + // Prepare to read in the array of name hashes + // Note that the name hashes array is aligned to 8 bytes so + // we can use pointers into it on 64 bit machines. (4 bytes + // may be sufficient, but let's plan for the future) + // Skip over alignment stuff. All public .resources files + // should be aligned No need to verify the byte values. + var pos = reader.BaseStream.Position - fileStartPosition; + var alignBytes = unchecked((int)pos) & 7; + if (alignBytes != 0) + { + for (var i = 0; i < 8 - alignBytes; i++) + { + reader.ReadByte(); + } + } + + // Skip over the array of name hashes + try + { + reader.Seek(checked(4 * numResources), SeekOrigin.Current); + } + catch (OverflowException) + { + throw new BadImageFormatException(ResourcesHeaderCorrupted); + } + + // Read in the array of relative positions for all the names. + namePositions = new int[numResources]; + for (var i = 0; i < numResources; i++) + { + var namePosition = reader.ReadInt32(); + if (namePosition < 0) + { + throw new BadImageFormatException(ResourcesHeaderCorrupted); + } + namePositions[i] = namePosition; + } + + // Read location of data section. + var dataSectionOffset = reader.ReadInt32(); + if (dataSectionOffset < 0) + { + throw new BadImageFormatException(ResourcesHeaderCorrupted); + } + + // Store current location as start of name section + nameSectionPosition = reader.BaseStream.Position; + dataSectionPosition = fileStartPosition + dataSectionOffset; + + // _nameSectionOffset should be <= _dataSectionOffset; if not, it's corrupt + if (dataSectionPosition < nameSectionPosition) + { + throw new BadImageFormatException(ResourcesHeaderCorrupted); + } + } + + public void Dispose() + { + reader.Dispose(); + } + + public int ResourceCount => numResources; + + public string GetResourceName(int index) + { + return GetResourceName(index, out _); + } + + int GetResourceDataOffset(int index) + { + GetResourceName(index, out var dataOffset); + return dataOffset; + } + + string GetResourceName(int index, out int dataOffset) + { + var pos = nameSectionPosition + namePositions[index]; + byte[] bytes; + lock (reader) + { + reader.Seek(pos, SeekOrigin.Begin); + // Can't use reader.ReadString, since it's using UTF-8! + var byteLen = reader.Read7BitEncodedInt(); + if (byteLen < 0) + { + throw new BadImageFormatException("Resource name has negative length"); + } + bytes = new byte[byteLen]; + // We must read byteLen bytes, or we have a corrupted file. + // Use a blocking read in case the stream doesn't give us back + // everything immediately. + var count = byteLen; + while (count > 0) + { + var n = reader.Read(bytes, byteLen - count, count); + if (n == 0) + throw new BadImageFormatException("End of stream within a resource name"); + count -= n; + } + dataOffset = reader.ReadInt32(); + if (dataOffset < 0) + { + throw new BadImageFormatException("Negative data offset"); + } + } + return Encoding.Unicode.GetString(bytes); + } + + internal bool AllEntriesAreStreams() + { + if (version != 2) + return false; + lock (reader) + { + for (var i = 0; i < numResources; i++) + { + var dataOffset = GetResourceDataOffset(i); + reader.Seek(dataSectionPosition + dataOffset, SeekOrigin.Begin); + var typeCode = (ResourceTypeCode)reader.Read7BitEncodedInt(); + if (typeCode != ResourceTypeCode.Stream) + return false; + } + } + return true; + } + + object LoadObject(int dataOffset) + { + try + { + lock (reader) + { + if (version == 1) + { + return LoadObjectV1(dataOffset); + } + else + { + return LoadObjectV2(dataOffset); + } + } + } + catch (EndOfStreamException e) + { + throw new BadImageFormatException("Invalid resource file", e); + } + } + + string FindType(int typeIndex) + { + if (typeIndex < 0 || typeIndex >= typeTable.Length) + throw new BadImageFormatException("Type index out of bounds"); + return typeTable[typeIndex]; + } + + // This takes a virtual offset into the data section and reads an Object + // from that location. + // Anyone who calls LoadObject should make sure they take a lock so + // no one can cause us to do a seek in here. + private object LoadObjectV1(int dataOffset) + { + Debug.Assert(System.Threading.Monitor.IsEntered(reader)); + reader.Seek(dataSectionPosition + dataOffset, SeekOrigin.Begin); + var typeIndex = reader.Read7BitEncodedInt(); + if (typeIndex == -1) + return null; + var typeName = FindType(typeIndex); + var comma = typeName.IndexOf(','); + if (comma > 0) + { + // strip assembly name + typeName = typeName.Substring(0, comma); + } + switch (typeName) + { + case "System.String": + return reader.ReadString(); + case "System.Byte": + return reader.ReadByte(); + case "System.SByte": + return reader.ReadSByte(); + case "System.Int16": + return reader.ReadInt16(); + case "System.UInt16": + return reader.ReadUInt16(); + case "System.Int32": + return reader.ReadInt32(); + case "System.UInt32": + return reader.ReadUInt32(); + case "System.Int64": + return reader.ReadInt64(); + case "System.UInt64": + return reader.ReadUInt64(); + case "System.Single": + return reader.ReadSingle(); + case "System.Double": + return reader.ReadDouble(); + case "System.DateTime": + // Ideally we should use DateTime's ToBinary & FromBinary, + // but we can't for compatibility reasons. + return new DateTime(reader.ReadInt64()); + case "System.TimeSpan": + return new TimeSpan(reader.ReadInt64()); + case "System.Decimal": + var bits = new int[4]; + for (var i = 0; i < bits.Length; i++) + bits[i] = reader.ReadInt32(); + return new decimal(bits); + default: + return new ResourceSerializedObject(FindType(typeIndex), this, reader.BaseStream.Position); + } + } + + private object LoadObjectV2(int dataOffset) + { + Debug.Assert(System.Threading.Monitor.IsEntered(reader)); + reader.Seek(dataSectionPosition + dataOffset, SeekOrigin.Begin); + var typeCode = (ResourceTypeCode)reader.Read7BitEncodedInt(); + switch (typeCode) + { + case ResourceTypeCode.Null: + return null; + + case ResourceTypeCode.String: + return reader.ReadString(); + + case ResourceTypeCode.Boolean: + return reader.ReadBoolean(); + + case ResourceTypeCode.Char: + return (char)reader.ReadUInt16(); + + case ResourceTypeCode.Byte: + return reader.ReadByte(); + + case ResourceTypeCode.SByte: + return reader.ReadSByte(); + + case ResourceTypeCode.Int16: + return reader.ReadInt16(); + + case ResourceTypeCode.UInt16: + return reader.ReadUInt16(); + + case ResourceTypeCode.Int32: + return reader.ReadInt32(); + + case ResourceTypeCode.UInt32: + return reader.ReadUInt32(); + + case ResourceTypeCode.Int64: + return reader.ReadInt64(); + + case ResourceTypeCode.UInt64: + return reader.ReadUInt64(); + + case ResourceTypeCode.Single: + return reader.ReadSingle(); + + case ResourceTypeCode.Double: + return reader.ReadDouble(); + + case ResourceTypeCode.Decimal: + return reader.ReadDecimal(); + + case ResourceTypeCode.DateTime: + // Use DateTime's ToBinary & FromBinary. + var data = reader.ReadInt64(); + return DateTime.FromBinary(data); + + case ResourceTypeCode.TimeSpan: + var ticks = reader.ReadInt64(); + return new TimeSpan(ticks); + + // Special types + case ResourceTypeCode.ByteArray: + { + var len = reader.ReadInt32(); + if (len < 0) + { + throw new BadImageFormatException("Resource with negative length"); + } + return reader.ReadBytes(len); + } + + case ResourceTypeCode.Stream: + { + var len = reader.ReadInt32(); + if (len < 0) + { + throw new BadImageFormatException("Resource with negative length"); + } + var bytes = reader.ReadBytes(len); + return new MemoryStream(bytes, writable: false); + } + + default: + if (typeCode < ResourceTypeCode.StartOfUserTypes) + { + throw new BadImageFormatException("Invalid typeCode"); + } + return new ResourceSerializedObject(FindType(typeCode - ResourceTypeCode.StartOfUserTypes), this, reader.BaseStream.Position); + } + } + + public object GetResourceValue(int index) + { + GetResourceName(index, out var dataOffset); + return LoadObject(dataOffset); + } + + public IEnumerator> GetEnumerator() + { + for (var i = 0; i < numResources; i++) + { + var name = GetResourceName(i, out var dataOffset); + var val = LoadObject(dataOffset); + yield return new KeyValuePair(name, val); + } + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + long[] GetStartPositions() + { + var positions = LazyInit.VolatileRead(ref startPositions); + if (positions != null) + return positions; + lock (reader) + { + // double-checked locking + positions = LazyInit.VolatileRead(ref startPositions); + if (positions != null) + return positions; + positions = new long[numResources * 2]; + var outPos = 0; + for (var i = 0; i < numResources; i++) + { + positions[outPos++] = nameSectionPosition + namePositions[i]; + positions[outPos++] = dataSectionPosition + GetResourceDataOffset(i); + } + Array.Sort(positions); + return LazyInit.GetOrSet(ref startPositions, positions); + } + } + + internal byte[] GetBytesForSerializedObject(long pos) + { + var positions = GetStartPositions(); + var i = Array.BinarySearch(positions, pos); + if (i < 0) + { + // 'pos' the the start position of the serialized object data + // This is the position after the type code, so it should not appear in the 'positions' array. + // Set i to the index of the next position after 'pos'. + i = ~i; + // Note: if 'pos' does exist in the array, that means the stream has length 0, + // so we keep the i that we found. + } + lock (reader) + { + long endPos; + if (i == positions.Length) + { + endPos = reader.BaseStream.Length; + } + else + { + endPos = positions[i]; + } + var len = (int)(endPos - pos); + reader.Seek(pos, SeekOrigin.Begin); + return reader.ReadBytes(len); + } + } + } + + public class ResourceSerializedObject + { + public string TypeName { get; } + readonly ResourcesFile file; + readonly long position; + + internal ResourceSerializedObject(string typeName, ResourcesFile file, long position) + { + this.TypeName = typeName; + this.file = file; + this.position = position; + } + + /// + /// Gets a stream that starts with the serialized object data. + /// + public Stream GetStream() + { + return new MemoryStream(file.GetBytesForSerializedObject(position), writable: false); + } + + /// + /// Gets the serialized object data. + /// + public byte[] GetBytes() + { + return file.GetBytesForSerializedObject(position); + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/TreeTraversal.cs b/src/ICSharpCode.Decompiler/Util/TreeTraversal.cs new file mode 100644 index 0000000..d22a158 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/TreeTraversal.cs @@ -0,0 +1,128 @@ +// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System; +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.Util +{ + /// + /// Static helper methods for traversing trees. + /// + public static class TreeTraversal + { + /// + /// Converts a tree data structure into a flat list by traversing it in pre-order. + /// + /// The root element of the tree. + /// The function that gets the children of an element. + /// Iterator that enumerates the tree structure in pre-order. + public static IEnumerable PreOrder(T root, Func> recursion) + { + return PreOrder(new T[] { root }, recursion); + } + + /// + /// Converts a tree data structure into a flat list by traversing it in pre-order. + /// + /// The root elements of the forest. + /// The function that gets the children of an element. + /// Iterator that enumerates the tree structure in pre-order. + public static IEnumerable PreOrder(IEnumerable input, Func> recursion) + { + var stack = new Stack>(); + try + { + stack.Push(input.GetEnumerator()); + while (stack.Count > 0) + { + while (stack.Peek().MoveNext()) + { + var element = stack.Peek().Current; + yield return element; + var children = recursion(element); + if (children != null) + { + stack.Push(children.GetEnumerator()); + } + } + stack.Pop().Dispose(); + } + } + finally + { + while (stack.Count > 0) + { + stack.Pop().Dispose(); + } + } + } + + /// + /// Converts a tree data structure into a flat list by traversing it in post-order. + /// + /// The root element of the tree. + /// The function that gets the children of an element. + /// Iterator that enumerates the tree structure in post-order. + public static IEnumerable PostOrder(T root, Func> recursion) + { + return PostOrder(new T[] { root }, recursion); + } + + /// + /// Converts a tree data structure into a flat list by traversing it in post-order. + /// + /// The root elements of the forest. + /// The function that gets the children of an element. + /// Iterator that enumerates the tree structure in post-order. + public static IEnumerable PostOrder(IEnumerable input, Func> recursion) + { + var stack = new Stack>(); + try + { + stack.Push(input.GetEnumerator()); + while (stack.Count > 0) + { + while (stack.Peek().MoveNext()) + { + var element = stack.Peek().Current; + var children = recursion(element); + if (children != null) + { + stack.Push(children.GetEnumerator()); + } + else + { + yield return element; + } + } + stack.Pop().Dispose(); + if (stack.Count > 0) + yield return stack.Peek().Current; + } + } + finally + { + while (stack.Count > 0) + { + stack.Pop().Dispose(); + } + } + } + } +} diff --git a/src/ICSharpCode.Decompiler/Util/UnicodeNewline.cs b/src/ICSharpCode.Decompiler/Util/UnicodeNewline.cs new file mode 100644 index 0000000..dca342c --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/UnicodeNewline.cs @@ -0,0 +1,381 @@ +// +// UnicodeNewline.cs +// +// Author: +// Mike Krüger +// +// Copyright (c) 2013 Xamarin Inc. (http://xamarin.com) +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +using System; + +namespace ICSharpCode.Decompiler.Util +{ + public enum UnicodeNewline + { + Unknown, + + /// + /// Line Feed, U+000A + /// + LF = 0x0A, + + + CRLF = 0x0D0A, + + /// + /// Carriage Return, U+000D + /// + CR = 0x0D, + + /// + /// Next Line, U+0085 + /// + NEL = 0x85, + + /// + /// Vertical Tab, U+000B + /// + VT = 0x0B, + + /// + /// Form Feed, U+000C + /// + FF = 0x0C, + + /// + /// Line Separator, U+2028 + /// + LS = 0x2028, + + /// + /// Paragraph Separator, U+2029 + /// + PS = 0x2029 + } + + + /// + /// Defines unicode new lines according to Unicode Technical Report #13 + /// http://www.unicode.org/standard/reports/tr13/tr13-5.html + /// + public static class NewLine + { + /// + /// Carriage Return, U+000D + /// + public const char CR = (char)0x0D; + + /// + /// Line Feed, U+000A + /// + public const char LF = (char)0x0A; + + /// + /// Next Line, U+0085 + /// + public const char NEL = (char)0x85; + + /// + /// Vertical Tab, U+000B + /// + public const char VT = (char)0x0B; + + /// + /// Form Feed, U+000C + /// + public const char FF = (char)0x0C; + + /// + /// Line Separator, U+2028 + /// + public const char LS = (char)0x2028; + + /// + /// Paragraph Separator, U+2029 + /// + public const char PS = (char)0x2029; + + /// + /// Determines if a char is a new line delimiter. + /// + /// 0 == no new line, otherwise it returns either 1 or 2 depending of the length of the delimiter. + /// The current character. + /// A callback getting the next character (may be null). + public static int GetDelimiterLength(char curChar, Func nextChar = null) + { + if (curChar == CR) + { + if (nextChar != null && nextChar() == LF) + return 2; + return 1; + } + + if (curChar == LF || curChar == NEL || curChar == VT || curChar == FF || curChar == LS || curChar == PS) + return 1; + return 0; + } + + /// + /// Determines if a char is a new line delimiter. + /// + /// 0 == no new line, otherwise it returns either 1 or 2 depending of the length of the delimiter. + /// The current character. + /// The next character (if != LF then length will always be 0 or 1). + public static int GetDelimiterLength(char curChar, char nextChar) + { + if (curChar == CR) + { + if (nextChar == LF) + return 2; + return 1; + } + + if (curChar == LF || curChar == NEL || curChar == VT || curChar == FF || curChar == LS || curChar == PS) + return 1; + return 0; + } + + + /// + /// Determines if a char is a new line delimiter. + /// + /// 0 == no new line, otherwise it returns either 1 or 2 depending of the length of the delimiter. + /// The current character. + /// The length of the delimiter + /// The type of the delimiter + /// A callback getting the next character (may be null). + public static bool TryGetDelimiterLengthAndType(char curChar, out int length, out UnicodeNewline type, Func nextChar = null) + { + if (curChar == CR) + { + if (nextChar != null && nextChar() == LF) + { + length = 2; + type = UnicodeNewline.CRLF; + } + else + { + length = 1; + type = UnicodeNewline.CR; + + } + return true; + } + + switch (curChar) + { + case LF: + type = UnicodeNewline.LF; + length = 1; + return true; + case NEL: + type = UnicodeNewline.NEL; + length = 1; + return true; + case VT: + type = UnicodeNewline.VT; + length = 1; + return true; + case FF: + type = UnicodeNewline.FF; + length = 1; + return true; + case LS: + type = UnicodeNewline.LS; + length = 1; + return true; + case PS: + type = UnicodeNewline.PS; + length = 1; + return true; + } + length = -1; + type = UnicodeNewline.Unknown; + return false; + } + + /// + /// Determines if a char is a new line delimiter. + /// + /// 0 == no new line, otherwise it returns either 1 or 2 depending of the length of the delimiter. + /// The current character. + /// The length of the delimiter + /// The type of the delimiter + /// The next character (if != LF then length will always be 0 or 1). + public static bool TryGetDelimiterLengthAndType(char curChar, out int length, out UnicodeNewline type, char nextChar) + { + if (curChar == CR) + { + if (nextChar == LF) + { + length = 2; + type = UnicodeNewline.CRLF; + } + else + { + length = 1; + type = UnicodeNewline.CR; + + } + return true; + } + + switch (curChar) + { + case LF: + type = UnicodeNewline.LF; + length = 1; + return true; + case NEL: + type = UnicodeNewline.NEL; + length = 1; + return true; + case VT: + type = UnicodeNewline.VT; + length = 1; + return true; + case FF: + type = UnicodeNewline.FF; + length = 1; + return true; + case LS: + type = UnicodeNewline.LS; + length = 1; + return true; + case PS: + type = UnicodeNewline.PS; + length = 1; + return true; + } + length = -1; + type = UnicodeNewline.Unknown; + return false; + } + + /// + /// Gets the new line type of a given char/next char. + /// + /// 0 == no new line, otherwise it returns either 1 or 2 depending of the length of the delimiter. + /// The current character. + /// A callback getting the next character (may be null). + public static UnicodeNewline GetDelimiterType(char curChar, Func nextChar = null) + { + switch (curChar) + { + case CR: + if (nextChar != null && nextChar() == LF) + return UnicodeNewline.CRLF; + return UnicodeNewline.CR; + case LF: + return UnicodeNewline.LF; + case NEL: + return UnicodeNewline.NEL; + case VT: + return UnicodeNewline.VT; + case FF: + return UnicodeNewline.FF; + case LS: + return UnicodeNewline.LS; + case PS: + return UnicodeNewline.PS; + } + return UnicodeNewline.Unknown; + } + + /// + /// Gets the new line type of a given char/next char. + /// + /// 0 == no new line, otherwise it returns either 1 or 2 depending of the length of the delimiter. + /// The current character. + /// The next character (if != LF then length will always be 0 or 1). + public static UnicodeNewline GetDelimiterType(char curChar, char nextChar) + { + switch (curChar) + { + case CR: + if (nextChar == LF) + return UnicodeNewline.CRLF; + return UnicodeNewline.CR; + case LF: + return UnicodeNewline.LF; + case NEL: + return UnicodeNewline.NEL; + case VT: + return UnicodeNewline.VT; + case FF: + return UnicodeNewline.FF; + case LS: + return UnicodeNewline.LS; + case PS: + return UnicodeNewline.PS; + } + return UnicodeNewline.Unknown; + } + + /// + /// Determines if a char is a new line delimiter. + /// + /// Note that the only 2 char wide new line is CR LF and both chars are new line + /// chars on their own. For most cases GetDelimiterLength is the better choice. + /// + public static bool IsNewLine(char ch) + { + return + ch == NewLine.CR || + ch == NewLine.LF || + ch == NewLine.NEL || + ch == NewLine.VT || + ch == NewLine.FF || + ch == NewLine.LS || + ch == NewLine.PS; + } + + /// + /// Gets the new line as a string. + /// + public static string GetString(UnicodeNewline newLine) + { + switch (newLine) + { + case UnicodeNewline.Unknown: + return ""; + case UnicodeNewline.LF: + return "\n"; + case UnicodeNewline.CRLF: + return "\r\n"; + case UnicodeNewline.CR: + return "\r"; + case UnicodeNewline.NEL: + return "\u0085"; + case UnicodeNewline.VT: + return "\u000B"; + case UnicodeNewline.FF: + return "\u000C"; + case UnicodeNewline.LS: + return "\u2028"; + case UnicodeNewline.PS: + return "\u2029"; + default: + throw new ArgumentOutOfRangeException(); + } + } + } +} + diff --git a/src/ICSharpCode.Decompiler/Util/UnionFind.cs b/src/ICSharpCode.Decompiler/Util/UnionFind.cs new file mode 100644 index 0000000..4bc0acb --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/UnionFind.cs @@ -0,0 +1,88 @@ +// Copyright (c) 2014 Daniel Grunwald +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this +// software and associated documentation files (the "Software"), to deal in the Software +// without restriction, including without limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons +// to whom the Software is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or +// substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. + +using System.Collections.Generic; + +namespace ICSharpCode.Decompiler.Util +{ + /// + /// Union-Find data structure. + /// + public class UnionFind + { + Dictionary mapping; + + class Node + { + public int rank; + public Node parent; + public T value; + } + + public UnionFind() + { + mapping = new Dictionary(); + } + + Node GetNode(T element) + { + Node node; + if (!mapping.TryGetValue(element, out node)) + { + node = new Node { + value = element, + rank = 0 + }; + node.parent = node; + mapping.Add(element, node); + } + return node; + } + + public T Find(T element) + { + return FindRoot(GetNode(element)).value; + } + + Node FindRoot(Node node) + { + if (node.parent != node) + node.parent = FindRoot(node.parent); + return node.parent; + } + + public void Merge(T a, T b) + { + var rootA = FindRoot(GetNode(a)); + var rootB = FindRoot(GetNode(b)); + if (rootA == rootB) + return; + if (rootA.rank < rootB.rank) + rootA.parent = rootB; + else if (rootA.rank > rootB.rank) + rootB.parent = rootA; + else + { + rootB.parent = rootA; + rootA.rank++; + } + } + } +} + + diff --git a/src/ICSharpCode.Decompiler/Util/Win32Resources.cs b/src/ICSharpCode.Decompiler/Util/Win32Resources.cs new file mode 100644 index 0000000..7087a93 --- /dev/null +++ b/src/ICSharpCode.Decompiler/Util/Win32Resources.cs @@ -0,0 +1,295 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection.PortableExecutable; + +#pragma warning disable CS0649 // only default value. + +namespace ICSharpCode.Decompiler.Util +{ + /// + /// Represents win32 resources + /// + public static class Win32Resources + { + /// + /// Reads win32 resource root directory + /// + /// + /// + public static unsafe Win32ResourceDirectory ReadWin32Resources(this PEReader pe) + { + if (pe == null) + { + throw new ArgumentNullException(nameof(pe)); + } + + var rva = pe.PEHeaders.PEHeader.ResourceTableDirectory.RelativeVirtualAddress; + if (rva == 0) + return null; + var pRoot = pe.GetSectionData(rva).Pointer; + return new Win32ResourceDirectory(pe, pRoot, 0, new Win32ResourceName("Root")); + } + + public static Win32ResourceDirectory Find(this Win32ResourceDirectory root, Win32ResourceName type) + { + if (root is null) + throw new ArgumentNullException(nameof(root)); + if (!root.Name.HasName || root.Name.Name != "Root") + throw new ArgumentOutOfRangeException(nameof(root)); + if (type is null) + throw new ArgumentNullException(nameof(type)); + + return root.FindDirectory(type); + } + + public static Win32ResourceDirectory Find(this Win32ResourceDirectory root, Win32ResourceName type, Win32ResourceName name) + { + if (root is null) + throw new ArgumentNullException(nameof(root)); + if (!root.Name.HasName || root.Name.Name != "Root") + throw new ArgumentOutOfRangeException(nameof(root)); + if (type is null) + throw new ArgumentNullException(nameof(type)); + if (name is null) + throw new ArgumentNullException(nameof(name)); + + return root.FindDirectory(type)?.FindDirectory(name); + } + + public static Win32ResourceData Find(this Win32ResourceDirectory root, Win32ResourceName type, Win32ResourceName name, Win32ResourceName langId) + { + if (root is null) + throw new ArgumentNullException(nameof(root)); + if (!root.Name.HasName || root.Name.Name != "Root") + throw new ArgumentOutOfRangeException(nameof(root)); + if (type is null) + throw new ArgumentNullException(nameof(type)); + if (name is null) + throw new ArgumentNullException(nameof(name)); + if (langId is null) + throw new ArgumentNullException(nameof(langId)); + + return root.FindDirectory(type)?.FindDirectory(name)?.FindData(langId); + } + } + + [DebuggerDisplay("Directory: {Name}")] + public sealed class Win32ResourceDirectory + { + #region Structure + public uint Characteristics { get; } + public uint TimeDateStamp { get; } + public ushort MajorVersion { get; } + public ushort MinorVersion { get; } + public ushort NumberOfNamedEntries { get; } + public ushort NumberOfIdEntries { get; } + #endregion + + public Win32ResourceName Name { get; } + + public IList Directories { get; } + + public IList Datas { get; } + + internal unsafe Win32ResourceDirectory(PEReader pe, byte* pRoot, int offset, Win32ResourceName name) + { + var p = (IMAGE_RESOURCE_DIRECTORY*)(pRoot + offset); + Characteristics = p->Characteristics; + TimeDateStamp = p->TimeDateStamp; + MajorVersion = p->MajorVersion; + MinorVersion = p->MinorVersion; + NumberOfNamedEntries = p->NumberOfNamedEntries; + NumberOfIdEntries = p->NumberOfIdEntries; + + Name = name; + Directories = new List(); + Datas = new List(); + var pEntries = (IMAGE_RESOURCE_DIRECTORY_ENTRY*)(p + 1); + var total = NumberOfNamedEntries + NumberOfIdEntries; + for (var i = 0; i < total; i++) + { + var pEntry = pEntries + i; + name = new Win32ResourceName(pRoot, pEntry); + if ((pEntry->OffsetToData & 0x80000000) == 0) + Datas.Add(new Win32ResourceData(pe, pRoot, (int)pEntry->OffsetToData, name)); + else + Directories.Add(new Win32ResourceDirectory(pe, pRoot, (int)(pEntry->OffsetToData & 0x7FFFFFFF), name)); + } + } + + static unsafe string ReadString(byte* pRoot, int offset) + { + var pString = (IMAGE_RESOURCE_DIRECTORY_STRING*)(pRoot + offset); + return new string(pString->NameString, 0, pString->Length); + } + + public Win32ResourceDirectory FindDirectory(Win32ResourceName name) + { + foreach (var directory in Directories) + { + if (directory.Name == name) + return directory; + } + return null; + } + + public Win32ResourceData FindData(Win32ResourceName name) + { + foreach (var data in Datas) + { + if (data.Name == name) + return data; + } + return null; + } + + public Win32ResourceDirectory FirstDirectory() + { + return Directories.Count != 0 ? Directories[0] : null; + } + + public Win32ResourceData FirstData() + { + return Datas.Count != 0 ? Datas[0] : null; + } + } + + [DebuggerDisplay("Data: {Name}")] + public sealed unsafe class Win32ResourceData + { + #region Structure + public uint OffsetToData { get; } + public uint Size { get; } + public uint CodePage { get; } + public uint Reserved { get; } + #endregion + + private readonly void* _pointer; + + public Win32ResourceName Name { get; } + + public byte[] Data { + get { + var data = new byte[Size]; + fixed (void* pData = data) + Buffer.MemoryCopy(_pointer, pData, Size, Size); + return data; + } + } + + internal Win32ResourceData(PEReader pe, byte* pRoot, int offset, Win32ResourceName name) + { + var p = (IMAGE_RESOURCE_DATA_ENTRY*)(pRoot + offset); + OffsetToData = p->OffsetToData; + Size = p->Size; + CodePage = p->CodePage; + Reserved = p->Reserved; + + _pointer = pe.GetSectionData((int)OffsetToData).Pointer; + Name = name; + } + } + + public sealed class Win32ResourceName + { + private readonly object _name; + + public bool HasName => _name is string; + + public bool HasId => _name is ushort; + + public string Name => (string)_name; + + public ushort Id => (ushort)_name; + + public Win32ResourceName(string name) + { + _name = name ?? throw new ArgumentNullException(nameof(name)); + } + + public Win32ResourceName(int id) : this(checked((ushort)id)) + { + } + + public Win32ResourceName(ushort id) + { + _name = id; + } + + internal unsafe Win32ResourceName(byte* pRoot, IMAGE_RESOURCE_DIRECTORY_ENTRY* pEntry) + { + _name = (pEntry->Name & 0x80000000) == 0 ? (object)(ushort)pEntry->Name : ReadString(pRoot, (int)(pEntry->Name & 0x7FFFFFFF)); + + static string ReadString(byte* pRoot, int offset) + { + var pString = (IMAGE_RESOURCE_DIRECTORY_STRING*)(pRoot + offset); + return new string(pString->NameString, 0, pString->Length); + } + } + + public static bool operator ==(Win32ResourceName x, Win32ResourceName y) + { + if (x.HasName) + { + return y.HasName ? string.Compare(x.Name, y.Name, StringComparison.OrdinalIgnoreCase) == 0 : false; + } + else + { + return y.HasId ? x.Id == y.Id : false; + } + } + + public static bool operator !=(Win32ResourceName x, Win32ResourceName y) + { + return !(x == y); + } + + public override int GetHashCode() + { + return _name.GetHashCode(); + } + + public override bool Equals(object obj) + { + if (!(obj is Win32ResourceName name)) + return false; + return this == name; + } + + public override string ToString() + { + return HasName ? $"Name: {Name}" : $"Id: {Id}"; + } + } + + internal struct IMAGE_RESOURCE_DIRECTORY + { + public uint Characteristics; + public uint TimeDateStamp; + public ushort MajorVersion; + public ushort MinorVersion; + public ushort NumberOfNamedEntries; + public ushort NumberOfIdEntries; + } + + internal struct IMAGE_RESOURCE_DIRECTORY_ENTRY + { + public uint Name; + public uint OffsetToData; + } + + internal unsafe struct IMAGE_RESOURCE_DIRECTORY_STRING + { + public ushort Length; + public fixed char NameString[1]; + } + + internal struct IMAGE_RESOURCE_DATA_ENTRY + { + public uint OffsetToData; + public uint Size; + public uint CodePage; + public uint Reserved; + } +} diff --git a/src/Pharmacist.Benchmarks/CommentGenerator.cs b/src/Pharmacist.Benchmarks/CommentGenerator.cs index d1179ea..187e3a5 100644 --- a/src/Pharmacist.Benchmarks/CommentGenerator.cs +++ b/src/Pharmacist.Benchmarks/CommentGenerator.cs @@ -10,7 +10,7 @@ namespace Pharmacist.Benchmarks { - [SimpleJob(RuntimeMoniker.Net472)] + [SimpleJob(RuntimeMoniker.Net461)] [SimpleJob(RuntimeMoniker.NetCoreApp31)] [MemoryDiagnoser] [MarkdownExporterAttribute.GitHub] diff --git a/src/Pharmacist.Benchmarks/NuGetHelperBenchmarks.cs b/src/Pharmacist.Benchmarks/NuGetHelperBenchmarks.cs index a2b478e..659cc75 100644 --- a/src/Pharmacist.Benchmarks/NuGetHelperBenchmarks.cs +++ b/src/Pharmacist.Benchmarks/NuGetHelperBenchmarks.cs @@ -12,7 +12,7 @@ namespace Pharmacist.Benchmarks { - [SimpleJob(RuntimeMoniker.Net472)] + [SimpleJob(RuntimeMoniker.Net461)] [SimpleJob(RuntimeMoniker.NetCoreApp31)] [MemoryDiagnoser] [MarkdownExporterAttribute.GitHub] diff --git a/src/Pharmacist.Benchmarks/Pharmacist.Benchmarks.csproj b/src/Pharmacist.Benchmarks/Pharmacist.Benchmarks.csproj index 3435ed5..d400172 100644 --- a/src/Pharmacist.Benchmarks/Pharmacist.Benchmarks.csproj +++ b/src/Pharmacist.Benchmarks/Pharmacist.Benchmarks.csproj @@ -3,13 +3,20 @@ Exe false - net461;netcoreapp2.2 + net472;netcoreapp3.1;net5.0 + + + + + + + diff --git a/src/Pharmacist.Benchmarks/PlatformGeneratorBenchmarks.cs b/src/Pharmacist.Benchmarks/PlatformGeneratorBenchmarks.cs index 3402f7e..a890761 100644 --- a/src/Pharmacist.Benchmarks/PlatformGeneratorBenchmarks.cs +++ b/src/Pharmacist.Benchmarks/PlatformGeneratorBenchmarks.cs @@ -15,7 +15,7 @@ namespace Pharmacist.Benchmarks /// /// Benchmarks for the NavigationStack and the RoutingState objects. /// - [SimpleJob(RuntimeMoniker.Net472)] + [SimpleJob(RuntimeMoniker.Net461)] [SimpleJob(RuntimeMoniker.NetCoreApp31)] [MemoryDiagnoser] [MarkdownExporterAttribute.GitHub] diff --git a/src/Pharmacist.Common/Pharmacist.Common.csproj b/src/Pharmacist.Common/Pharmacist.Common.csproj index 20cd639..5005c7b 100644 --- a/src/Pharmacist.Common/Pharmacist.Common.csproj +++ b/src/Pharmacist.Common/Pharmacist.Common.csproj @@ -1,14 +1,15 @@  - netstandard2.0 + netstandard2.0;net5.0 + $(TargetFrameworks);net472 Pharmacist.Common enable latest - + diff --git a/src/Pharmacist.Common/SingleAwaitSubject.cs b/src/Pharmacist.Common/SingleAwaitSubject.cs index d89aa67..553b160 100644 --- a/src/Pharmacist.Common/SingleAwaitSubject.cs +++ b/src/Pharmacist.Common/SingleAwaitSubject.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -15,7 +15,7 @@ namespace Pharmacist.Common /// The type of signals given by the subject. public sealed class SingleAwaitSubject : ISubject, IDisposable { - private readonly Subject _inner = new Subject(); + private readonly Subject _inner = new(); /// /// Gets the awaiter based on the first item in the collection. diff --git a/src/Pharmacist.Console/CommandOptions/CommandLineOptionsBase.cs b/src/Pharmacist.Console/CommandOptions/CommandLineOptionsBase.cs index 6f15131..0117f8c 100644 --- a/src/Pharmacist.Console/CommandOptions/CommandLineOptionsBase.cs +++ b/src/Pharmacist.Console/CommandOptions/CommandLineOptionsBase.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.Console/CommandOptions/CustomAssembliesCommandLineOptions.cs b/src/Pharmacist.Console/CommandOptions/CustomAssembliesCommandLineOptions.cs index 3c81984..d593fbf 100644 --- a/src/Pharmacist.Console/CommandOptions/CustomAssembliesCommandLineOptions.cs +++ b/src/Pharmacist.Console/CommandOptions/CustomAssembliesCommandLineOptions.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.Console/CommandOptions/NugetCommandLineOptions.cs b/src/Pharmacist.Console/CommandOptions/NugetCommandLineOptions.cs index 9214180..c41ec61 100644 --- a/src/Pharmacist.Console/CommandOptions/NugetCommandLineOptions.cs +++ b/src/Pharmacist.Console/CommandOptions/NugetCommandLineOptions.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.Console/CommandOptions/PlatformCommandLineOptions.cs b/src/Pharmacist.Console/CommandOptions/PlatformCommandLineOptions.cs index bb33f87..3d8f746 100644 --- a/src/Pharmacist.Console/CommandOptions/PlatformCommandLineOptions.cs +++ b/src/Pharmacist.Console/CommandOptions/PlatformCommandLineOptions.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -7,8 +7,6 @@ using CommandLine; -using Pharmacist.Core; - namespace Pharmacist.Console.CommandOptions { /// @@ -18,10 +16,22 @@ namespace Pharmacist.Console.CommandOptions public class PlatformCommandLineOptions : CommandLineOptionsBase { /// - /// Gets or sets the platform. + /// Gets or sets the target framework. + /// + [Option('t', "target-frameworks", Required = true, HelpText = "Specify the target framework monikiers.", Separator = ',')] + public IEnumerable? TargetFrameworks { get; set; } + + /// + /// Gets or sets a value indicating whether to use WPF. + /// + [Option("is-wpf", Required = false, HelpText = "Specify if WPF libraries should be used.")] + public bool IsWpf { get; set; } + + /// + /// Gets or sets a value indicating whether to use WinForms. /// - [Option('p', "platforms", Separator = ',', Required = true, HelpText = "Platform to automatically generate. Possible options include: ANDROID, IOS, WPF, MAC, TIZEN, UWP, XAMFORMS, WINFORMS, TVOS, ESSENTIALS")] - public IEnumerable? Platforms { get; set; } + [Option("is-winforms", Required = false, HelpText = "Specify if WinForms libraries should be used.")] + public bool IsWinForms { get; set; } /// /// Gets or sets the reference assemblies. diff --git a/src/Pharmacist.Console/ExitCode.cs b/src/Pharmacist.Console/ExitCode.cs index c035e38..e693bbe 100644 --- a/src/Pharmacist.Console/ExitCode.cs +++ b/src/Pharmacist.Console/ExitCode.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -18,6 +18,6 @@ public enum ExitCode /// /// Error. /// - Error = 1, + Error = 1 } } diff --git a/src/Pharmacist.Console/Pharmacist.Console.csproj b/src/Pharmacist.Console/Pharmacist.Console.csproj index fa7c303..e6a87ac 100644 --- a/src/Pharmacist.Console/Pharmacist.Console.csproj +++ b/src/Pharmacist.Console/Pharmacist.Console.csproj @@ -1,7 +1,7 @@  Exe - netcoreapp3.1 + net5.0 Pharmacist latest true diff --git a/src/Pharmacist.Console/Program.cs b/src/Pharmacist.Console/Program.cs index c869502..b6822d7 100644 --- a/src/Pharmacist.Console/Program.cs +++ b/src/Pharmacist.Console/Program.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -29,19 +29,19 @@ namespace Pharmacist.Console internal static class Program { [SuppressMessage("Design", "CA1031: Catch specific exceptions", Justification = "Final logging location for exceptions.")] - [SuppressMessage("Design", "CA2000: Dispose items", Justification = "Will be cleaned up when application ends.")] public static async Task Main(string[] args) { // allow app to be debugged in visual studio. if (args.Length == 0 && Debugger.IsAttached) { - args = "generate-platform --platforms=uwp --output-path=test.txt".Split(' '); + args = "generate-platform --is-wpf --target-frameworks=net5.0,net461,net462,net463,net470,net471,net472,net48 --output-path=c:/temp --output-prefix=blah".Split(' '); } var funcLogManager = new FuncLogManager(type => new WrappingFullLogger(new WrappingPrefixLogger(new ConsoleLogger(), type))); Locator.CurrentMutable.RegisterConstant(funcLogManager, typeof(ILogManager)); - var parserResult = new Parser(parserSettings => parserSettings.CaseInsensitiveEnumValues = true) + using var parser = new Parser(parserSettings => parserSettings.CaseInsensitiveEnumValues = true); + var parserResult = parser .ParseArguments(args); var result = await parserResult.MapResult( @@ -50,7 +50,7 @@ public static async Task Main(string[] args) try { var referenceAssembliesLocation = !string.IsNullOrWhiteSpace(options.ReferenceAssemblies) - ? options.ReferenceAssemblies! + ? options.ReferenceAssemblies : ReferenceLocator.GetReferenceLocation(); if (string.IsNullOrWhiteSpace(options.OutputPath)) @@ -63,12 +63,22 @@ public static async Task Main(string[] args) throw new Exception("Invalid output prefix for the event generation."); } - if (options.Platforms == null) + if (options.TargetFrameworks == null) { - throw new Exception("Invalid platforms for the event generation."); + throw new Exception("Invalid target framework for the event generation."); } - await ObservablesForEventGenerator.ExtractEventsFromPlatforms(options.OutputPath!, options.OutputPrefix!, ".cs", referenceAssembliesLocation, options.Platforms).ConfigureAwait(false); + foreach (var targetFramework in options.TargetFrameworks) + { + await ObservablesForEventGenerator.ExtractEventsFromPlatforms( + options.OutputPath, + options.OutputPrefix, + ".cs", + referenceAssembliesLocation, + targetFramework, + options.IsWpf, + options.IsWinForms).ConfigureAwait(false); + } return ExitCode.Success; } @@ -87,27 +97,26 @@ public static async Task Main(string[] args) throw new InvalidOperationException("There is no Output path specified."); } - using (var writer = new StreamWriter(Path.Combine(options.OutputPath, options.OutputPrefix + ".cs"))) + await using var writer = new StreamWriter(Path.Combine(options.OutputPath, options.OutputPrefix + ".cs")); + + if (options.Assemblies == null) { - if (options.Assemblies == null) - { - throw new Exception("Invalid specified assemblies for observable generation."); - } + throw new Exception("Invalid specified assemblies for observable generation."); + } - if (options.SearchDirectories == null) - { - throw new Exception("Invalid search directories specified for observable generation."); - } + if (options.SearchDirectories == null) + { + throw new Exception("Invalid search directories specified for observable generation."); + } - if (string.IsNullOrWhiteSpace(options.TargetFramework)) - { - throw new Exception("Invalid target framework for the event generation."); - } + if (string.IsNullOrWhiteSpace(options.TargetFramework)) + { + throw new Exception("Invalid target framework for the event generation."); + } - await ObservablesForEventGenerator.WriteHeader(writer, options.Assemblies!).ConfigureAwait(false); + await ObservablesForEventGenerator.WriteHeader(writer, options.Assemblies).ConfigureAwait(false); - await ObservablesForEventGenerator.ExtractEventsFromAssemblies(writer, options.Assemblies!, options.SearchDirectories!, options.TargetFramework!).ConfigureAwait(false); - } + await ObservablesForEventGenerator.ExtractEventsFromAssemblies(writer, options.Assemblies, options.SearchDirectories, options.TargetFramework).ConfigureAwait(false); return ExitCode.Success; } @@ -126,19 +135,17 @@ public static async Task Main(string[] args) throw new InvalidOperationException("There is no Output path specified."); } - using (var writer = new StreamWriter(Path.Combine(options.OutputPath, options.OutputPrefix + ".cs"))) + await using var writer = new StreamWriter(Path.Combine(options.OutputPath, options.OutputPrefix + ".cs")); + if (string.IsNullOrWhiteSpace(options.TargetFramework)) { - if (string.IsNullOrWhiteSpace(options.TargetFramework)) - { - throw new Exception("Invalid target framework for the event generation."); - } - - var packageIdentity = new[] { new LibraryRange(options.NugetPackageName, VersionRange.Parse(options.NugetVersion), LibraryDependencyTarget.Package) }; - var nugetFramework = options.TargetFramework!.ToFrameworks(); - await ObservablesForEventGenerator.WriteHeader(writer, packageIdentity).ConfigureAwait(false); - await ObservablesForEventGenerator.ExtractEventsFromNuGetPackages(writer, packageIdentity, nugetFramework, options.PackageFolder).ConfigureAwait(false); + throw new Exception("Invalid target framework for the event generation."); } + var packageIdentity = new[] { new LibraryRange(options.NugetPackageName, VersionRange.Parse(options.NugetVersion), LibraryDependencyTarget.Package) }; + var nugetFramework = options.TargetFramework.ToFrameworks(); + await ObservablesForEventGenerator.WriteHeader(writer, packageIdentity).ConfigureAwait(false); + await ObservablesForEventGenerator.ExtractEventsFromNuGetPackages(writer, packageIdentity, nugetFramework, options.PackageFolder).ConfigureAwait(false); + return ExitCode.Success; } catch (Exception ex) diff --git a/src/Pharmacist.Console/Properties/launchSettings.json b/src/Pharmacist.Console/Properties/launchSettings.json index abdbcdf..e1b5dba 100644 --- a/src/Pharmacist.Console/Properties/launchSettings.json +++ b/src/Pharmacist.Console/Properties/launchSettings.json @@ -1,8 +1,7 @@ { "profiles": { "EventBuilder.Console": { - "commandName": "Project", - "commandLineArgs": "generate-platform --platforms=\"essentials\" --reference=\"C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/Common7/IDE/ReferenceAssemblies/Microsoft/Framework\" --output-path=\"C:/source/reactiveui/reactiveui-rewrite/src/ReactiveUI.Events\" --output-prefix=\"Events_\"" + "commandName": "Project" } } } \ No newline at end of file diff --git a/src/Pharmacist.Core/AutoPlatform.cs b/src/Pharmacist.Core/AutoPlatform.cs deleted file mode 100644 index f81240e..0000000 --- a/src/Pharmacist.Core/AutoPlatform.cs +++ /dev/null @@ -1,50 +0,0 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. -// See the LICENSE file in the project root for full license information. - -namespace Pharmacist.Core -{ - /// - /// The event builder platform. - /// - public enum AutoPlatform - { - /// - /// Android platform. - /// - Android, - -#pragma warning disable SA1300 // Element should begin with upper-case letter - /// - /// iOS platform. - /// - iOS, -#pragma warning restore SA1300 // Element should begin with upper-case letter - - /// - /// Mac platform. - /// - Mac, - - /// - /// WPF platform. - /// - WPF, - - /// - /// UWP platform. - /// - UWP, - - /// - /// Win Forms platform. - /// - Winforms, - - /// - /// TV OS platform. - /// - TVOS, - } -} diff --git a/src/Pharmacist.Core/Comparers/AssemblyReferenceNameComparer.cs b/src/Pharmacist.Core/Comparers/AssemblyReferenceNameComparer.cs index ce66f0a..09f3ddc 100644 --- a/src/Pharmacist.Core/Comparers/AssemblyReferenceNameComparer.cs +++ b/src/Pharmacist.Core/Comparers/AssemblyReferenceNameComparer.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -11,12 +11,22 @@ namespace Pharmacist.Core.Comparers { internal class AssemblyReferenceNameComparer : IEqualityComparer { - public static AssemblyReferenceNameComparer Default { get; } = new AssemblyReferenceNameComparer(); + public static AssemblyReferenceNameComparer Default { get; } = new(); /// - public bool Equals(IAssemblyReference x, IAssemblyReference y) + public bool Equals(IAssemblyReference? x, IAssemblyReference? y) { - return StringComparer.InvariantCulture.Equals(x?.FullName, y?.FullName); + if (x == null && y == null) + { + return true; + } + + if (x == null || y == null) + { + return false; + } + + return StringComparer.InvariantCulture.Equals(x.FullName, y.FullName); } /// diff --git a/src/Pharmacist.Core/Comparers/NuGetFrameworkInRangeComparer.cs b/src/Pharmacist.Core/Comparers/NuGetFrameworkInRangeComparer.cs index a79a227..e87805e 100644 --- a/src/Pharmacist.Core/Comparers/NuGetFrameworkInRangeComparer.cs +++ b/src/Pharmacist.Core/Comparers/NuGetFrameworkInRangeComparer.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -12,11 +12,26 @@ namespace Pharmacist.Core.Comparers { internal class NuGetFrameworkInRangeComparer : IComparer, IEqualityComparer { - public static NuGetFrameworkInRangeComparer Default { get; } = new NuGetFrameworkInRangeComparer(); + public static NuGetFrameworkInRangeComparer Default { get; } = new(); /// - public bool Equals(NuGetFramework x, NuGetFramework y) + public bool Equals(NuGetFramework? x, NuGetFramework? y) { + if (x == null && y == null) + { + return true; + } + + if (x == null || y == null) + { + return false; + } + + if (ReferenceEquals(x, y)) + { + return true; + } + if (!NuGetFramework.FrameworkNameComparer.Equals(x, y)) { return false; @@ -32,16 +47,24 @@ public int GetHashCode(NuGetFramework obj) } /// - public int Compare(NuGetFramework x, NuGetFramework y) + public int Compare(NuGetFramework? x, NuGetFramework? y) { - var result = StringComparer.OrdinalIgnoreCase.Compare(x.Framework, y.Framework); + switch (x) + { + case null when y is null: + return 0; + case null: + return 1; + } - if (result != 0) + if (y is null) { - return result; + return -1; } - return x.Version.CompareTo(y.Version); + var result = StringComparer.OrdinalIgnoreCase.Compare(x.Framework, y.Framework); + + return result != 0 ? result : x.Version.CompareTo(y.Version); } } } diff --git a/src/Pharmacist.Core/Comparers/PackageIdentityNameComparer.cs b/src/Pharmacist.Core/Comparers/PackageIdentityNameComparer.cs index 5f0c902..65fe4ee 100644 --- a/src/Pharmacist.Core/Comparers/PackageIdentityNameComparer.cs +++ b/src/Pharmacist.Core/Comparers/PackageIdentityNameComparer.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -12,17 +12,22 @@ namespace Pharmacist.Core.Comparers { internal class PackageIdentityNameComparer : IEqualityComparer { - public static PackageIdentityNameComparer Default { get; } = new PackageIdentityNameComparer(); + public static PackageIdentityNameComparer Default { get; } = new(); /// - public bool Equals(PackageIdentity x, PackageIdentity y) + public bool Equals(PackageIdentity? x, PackageIdentity? y) { - if (x == y) + if (x == null && y == null) { return true; } - return StringComparer.OrdinalIgnoreCase.Equals(x?.Id, y?.Id); + if (x == null || y == null) + { + return false; + } + + return ReferenceEquals(x, y) || StringComparer.OrdinalIgnoreCase.Equals(x.Id, y.Id); } /// diff --git a/src/Pharmacist.Core/Extractors/IExtractor.cs b/src/Pharmacist.Core/Extractors/IExtractor.cs index e098487..8f078d2 100644 --- a/src/Pharmacist.Core/Extractors/IExtractor.cs +++ b/src/Pharmacist.Core/Extractors/IExtractor.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.Core/Extractors/NuGetExtractor.cs b/src/Pharmacist.Core/Extractors/NuGetExtractor.cs index ee05a25..0d1df52 100644 --- a/src/Pharmacist.Core/Extractors/NuGetExtractor.cs +++ b/src/Pharmacist.Core/Extractors/NuGetExtractor.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.Core/Extractors/PlatformExtractors/Android.cs b/src/Pharmacist.Core/Extractors/PlatformExtractors/Android.cs index 4483392..ffd10a3 100644 --- a/src/Pharmacist.Core/Extractors/PlatformExtractors/Android.cs +++ b/src/Pharmacist.Core/Extractors/PlatformExtractors/Android.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -10,7 +10,6 @@ using NuGet.Frameworks; -using Pharmacist.Core.Groups; using Pharmacist.Core.NuGet; using Pharmacist.Core.Utilities; @@ -24,15 +23,29 @@ namespace Pharmacist.Core.Extractors.PlatformExtractors public class Android : BasePlatform { /// - public override AutoPlatform Platform => AutoPlatform.Android; + public override bool CanExtract(NuGetFramework[] frameworks) + { + if (frameworks == null) + { + throw new ArgumentNullException(nameof(frameworks)); + } - /// - public override NuGetFramework Framework { get; } = "MonoAndroid90".ToFrameworks()[0]; + var framework = frameworks[0]; + + return framework.Framework.StartsWith("MonoAndroid", StringComparison.InvariantCultureIgnoreCase); + } /// - public override Task Extract(string referenceAssembliesLocation) + public override Task Extract(NuGetFramework[] frameworks, string referenceAssembliesLocation) { - Input.IncludeGroup.AddFiles(FileSystemHelpers.GetFilesWithinSubdirectories(Framework.GetNuGetFrameworkFolders(), AssemblyHelpers.AssemblyFileExtensionsSet).Where(x => Path.GetFileName(x).Equals("Mono.Android.dll", StringComparison.InvariantCultureIgnoreCase))); + if (frameworks == null) + { + throw new ArgumentNullException(nameof(frameworks)); + } + + var framework = frameworks[0]; + + Input.IncludeGroup.AddFiles(FileSystemHelpers.GetFilesWithinSubdirectories(framework.GetNuGetFrameworkFolders(), AssemblyHelpers.AssemblyFileExtensionsSet).Where(x => Path.GetFileName(x).Equals("Mono.Android.dll", StringComparison.InvariantCultureIgnoreCase))); return Task.CompletedTask; } } diff --git a/src/Pharmacist.Core/Extractors/PlatformExtractors/BasePlatform.cs b/src/Pharmacist.Core/Extractors/PlatformExtractors/BasePlatform.cs index 5df8fb2..1d78731 100644 --- a/src/Pharmacist.Core/Extractors/PlatformExtractors/BasePlatform.cs +++ b/src/Pharmacist.Core/Extractors/PlatformExtractors/BasePlatform.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -17,15 +17,12 @@ namespace Pharmacist.Core.Extractors.PlatformExtractors public abstract class BasePlatform : IPlatformExtractor { /// - public abstract AutoPlatform Platform { get; } + public InputAssembliesGroup Input { get; } = new(); /// - public abstract NuGetFramework Framework { get; } + public abstract bool CanExtract(NuGetFramework[] frameworks); /// - public InputAssembliesGroup Input { get; } = new InputAssembliesGroup(); - - /// - public abstract Task Extract(string referenceAssembliesLocation); + public abstract Task Extract(NuGetFramework[] frameworks, string referenceAssembliesLocation); } } diff --git a/src/Pharmacist.Core/Extractors/PlatformExtractors/IPlatformExtractor.cs b/src/Pharmacist.Core/Extractors/PlatformExtractors/IPlatformExtractor.cs index 1a0f32f..8c29b0b 100644 --- a/src/Pharmacist.Core/Extractors/PlatformExtractors/IPlatformExtractor.cs +++ b/src/Pharmacist.Core/Extractors/PlatformExtractors/IPlatformExtractor.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -15,20 +15,18 @@ namespace Pharmacist.Core.Extractors.PlatformExtractors public interface IPlatformExtractor : IExtractor { /// - /// Gets the event builder platform. + /// If the extractor can extract for the framework. /// - AutoPlatform Platform { get; } - - /// - /// Gets the framework that this platform is associated with. - /// - NuGetFramework Framework { get; } + /// The framework to check. + /// If the extraction works. + bool CanExtract(NuGetFramework[] frameworks); /// /// Extract details about the platform. /// + /// The frameworks to extract for. /// The location for reference assemblies if needed. /// A task to monitor the progress. - Task Extract(string referenceAssembliesLocation); + Task Extract(NuGetFramework[] frameworks, string referenceAssembliesLocation); } } diff --git a/src/Pharmacist.Core/Extractors/PlatformExtractors/Mac.cs b/src/Pharmacist.Core/Extractors/PlatformExtractors/Mac.cs index 21f1db7..69a86ab 100644 --- a/src/Pharmacist.Core/Extractors/PlatformExtractors/Mac.cs +++ b/src/Pharmacist.Core/Extractors/PlatformExtractors/Mac.cs @@ -1,16 +1,16 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. using System; +using System.Diagnostics.CodeAnalysis; using System.IO; using System.Linq; using System.Threading.Tasks; using NuGet.Frameworks; -using Pharmacist.Core.Groups; using Pharmacist.Core.NuGet; using Pharmacist.Core.Utilities; @@ -22,15 +22,30 @@ namespace Pharmacist.Core.Extractors.PlatformExtractors public class Mac : BasePlatform { /// - public override AutoPlatform Platform => AutoPlatform.Mac; + public override bool CanExtract(NuGetFramework[] frameworks) + { + if (frameworks == null) + { + throw new ArgumentNullException(nameof(frameworks)); + } - /// - public override NuGetFramework Framework { get; } = "Xamarin.Mac20".ToFrameworks()[0]; + var framework = frameworks[0]; + + return framework.Framework.StartsWith("Xamarin.Mac", StringComparison.InvariantCultureIgnoreCase); + } /// - public override Task Extract(string referenceAssembliesLocation) + [SuppressMessage("Usage", "CA2249:Consider using 'string.Contains' instead of 'string.IndexOf'", Justification = "Not supported on all platforms.")] + public override Task Extract(NuGetFramework[] frameworks, string referenceAssembliesLocation) { - Input.IncludeGroup.AddFiles(FileSystemHelpers.GetFilesWithinSubdirectories(Framework.GetNuGetFrameworkFolders(), AssemblyHelpers.AssemblyFileExtensionsSet).Where(x => Path.GetFileName(x).IndexOf("Xamarin.Mac", StringComparison.InvariantCultureIgnoreCase) >= 0)); + if (frameworks == null) + { + throw new ArgumentNullException(nameof(frameworks)); + } + + var framework = frameworks[0]; + + Input.IncludeGroup.AddFiles(FileSystemHelpers.GetFilesWithinSubdirectories(framework.GetNuGetFrameworkFolders(), AssemblyHelpers.AssemblyFileExtensionsSet).Where(x => Path.GetFileName(x).IndexOf("Xamarin.Mac", StringComparison.InvariantCultureIgnoreCase) >= 0)); return Task.CompletedTask; } diff --git a/src/Pharmacist.Core/Extractors/PlatformExtractors/NetCoreExtractorBase.cs b/src/Pharmacist.Core/Extractors/PlatformExtractors/NetCoreExtractorBase.cs deleted file mode 100644 index 5d92bd2..0000000 --- a/src/Pharmacist.Core/Extractors/PlatformExtractors/NetCoreExtractorBase.cs +++ /dev/null @@ -1,64 +0,0 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. -// See the LICENSE file in the project root for full license information. - -using System; -using System.Collections.Generic; -using System.IO; -using System.Linq; -using System.Threading.Tasks; -using NuGet.Frameworks; -using NuGet.LibraryModel; -using NuGet.Versioning; -using Pharmacist.Core.Groups; -using Pharmacist.Core.NuGet; - -namespace Pharmacist.Core.Extractors.PlatformExtractors -{ - /// - /// WPF platform assemblies and events. - /// - internal abstract class NetCoreExtractorBase : NuGetExtractor, IPlatformExtractor - { - private static readonly IReadOnlyList _frameworks = "netcoreapp3.1".ToFrameworks(); - private static readonly LibraryRange _windowsDesktopReference = new LibraryRange("Microsoft.WindowsDesktop.App.Ref", VersionRange.Parse("3.*"), LibraryDependencyTarget.Package); - - private readonly string? _filePath; - - public NetCoreExtractorBase(string? filePath) - { - _filePath = filePath ?? Path.GetTempPath(); - } - - /// - public NuGetFramework Framework { get; } = _frameworks[0]; - - /// - public abstract AutoPlatform Platform { get; } - - /// - /// Gets the wanted file names. - /// - protected abstract HashSet WantedFileNames { get; } - - /// - public async Task Extract(string referenceAssembliesLocation) - { - await Extract(_frameworks, new[] { _windowsDesktopReference }, _filePath).ConfigureAwait(false); - - if (Input == null) - { - return; - } - - var fileMetadataEnumerable = Input.IncludeGroup.GetAllFileNames().Where(file => WantedFileNames.Contains(Path.GetFileName(file), StringComparer.InvariantCultureIgnoreCase)); - - var newInput = new InputAssembliesGroup(); - newInput.IncludeGroup.AddFiles(fileMetadataEnumerable); - newInput.SupportGroup.AddFiles(Input.IncludeGroup.GetAllFileNames()); - newInput.SupportGroup.AddFiles(Input.SupportGroup.GetAllFileNames()); - Input = newInput; - } - } -} diff --git a/src/Pharmacist.Core/Extractors/PlatformExtractors/NetExtractorBase.cs b/src/Pharmacist.Core/Extractors/PlatformExtractors/NetExtractorBase.cs new file mode 100644 index 0000000..61b17a5 --- /dev/null +++ b/src/Pharmacist.Core/Extractors/PlatformExtractors/NetExtractorBase.cs @@ -0,0 +1,82 @@ +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Threading.Tasks; +using NuGet.Frameworks; +using NuGet.Packaging.Core; +using NuGet.Versioning; +using Pharmacist.Core.Groups; +using Pharmacist.Core.NuGet; + +namespace Pharmacist.Core.Extractors.PlatformExtractors +{ + /// + /// WPF platform assemblies and events. + /// + internal abstract class NetExtractorBase : NuGetExtractor, IPlatformExtractor + { + private const string NetFrameworkReferencePrefix = "Microsoft.NETFramework.ReferenceAssemblies"; + private const string WindowsDesktopRef = "Microsoft.WindowsDesktop.App.Ref"; + + private readonly string? _filePath; + + protected NetExtractorBase(string? filePath) + { + _filePath = filePath ?? Path.GetTempPath(); + } + + /// + /// Gets the wanted file names. + /// + protected abstract HashSet WantedFileNames { get; } + + public async Task Extract(NuGetFramework[] frameworks, string referenceAssembliesLocation) + { + if (frameworks == null) + { + throw new ArgumentNullException(nameof(frameworks)); + } + + var framework = frameworks[0]; + + var shortFileName = framework.GetShortFolderName(); + + InputAssembliesGroup results; + if (framework.IsDesktop()) + { + var reference = new PackageIdentity(NetFrameworkReferencePrefix + '.' + shortFileName, new NuGetVersion("1.0.0")); + + results = await NuGetPackageHelper.DownloadPackageFilesAndFolder(new[] { reference }, frameworks, packageOutputDirectory: _filePath).ConfigureAwait(false); + } + else + { + var reference = new PackageIdentity(WindowsDesktopRef, new NuGetVersion(framework.Version)); + + results = await NuGetPackageHelper.DownloadPackageFilesAndFolder(new[] { reference }, new[] { framework }, packageOutputDirectory: _filePath).ConfigureAwait(false); + } + + Input = results; + + if (Input == null) + { + return; + } + + var fileMetadataEnumerable = Input.IncludeGroup.GetAllFileNames().Where(file => WantedFileNames.Contains(Path.GetFileName(file))); + + var newInput = new InputAssembliesGroup(); + newInput.IncludeGroup.AddFiles(fileMetadataEnumerable); + newInput.SupportGroup.AddFiles(Input.IncludeGroup.GetAllFileNames()); + newInput.SupportGroup.AddFiles(Input.SupportGroup.GetAllFileNames()); + Input = newInput; + } + + public abstract bool CanExtract(NuGetFramework[] frameworks); + } +} diff --git a/src/Pharmacist.Core/Extractors/PlatformExtractors/NetFrameworkBase.cs b/src/Pharmacist.Core/Extractors/PlatformExtractors/NetFrameworkBase.cs deleted file mode 100644 index 63e9ecd..0000000 --- a/src/Pharmacist.Core/Extractors/PlatformExtractors/NetFrameworkBase.cs +++ /dev/null @@ -1,54 +0,0 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. -// See the LICENSE file in the project root for full license information. - -using System; -using System.Threading.Tasks; - -using NuGet.Frameworks; -using NuGet.Packaging.Core; -using NuGet.Versioning; - -using Pharmacist.Core.Groups; -using Pharmacist.Core.NuGet; - -namespace Pharmacist.Core.Extractors.PlatformExtractors -{ - /// - /// Any library that based on the NET Framework references. - /// - internal abstract class NetFrameworkBase : BasePlatform - { - private static readonly PackageIdentity ReferenceNuGet = new PackageIdentity("Microsoft.NETFramework.ReferenceAssemblies.net461", new NuGetVersion("1.0.0-preview.2")); - - private static readonly NuGetFramework ReferenceFramework = FrameworkConstants.CommonFrameworks.Net461; - - private readonly string? _filePath; - - protected NetFrameworkBase(string? filePath) - { - _filePath = filePath; - } - - /// - public override NuGetFramework Framework { get; } = "net461".ToFrameworks()[0]; - - /// - /// Building events for WPF on Mac is not implemented. - public override async Task Extract(string referenceAssembliesLocation) - { - var results = await NuGetPackageHelper.DownloadPackageFilesAndFolder(new[] { ReferenceNuGet }, new[] { ReferenceFramework }, packageOutputDirectory: _filePath).ConfigureAwait(false); - - Input.SupportGroup = results.SupportGroup; - - SetFiles(results); - } - - /// - /// Processes the files. - /// - /// The files. - protected abstract void SetFiles(InputAssembliesGroup folderGroups); - } -} diff --git a/src/Pharmacist.Core/Extractors/PlatformExtractors/UWP.cs b/src/Pharmacist.Core/Extractors/PlatformExtractors/UWP.cs index 30d465e..3822c19 100644 --- a/src/Pharmacist.Core/Extractors/PlatformExtractors/UWP.cs +++ b/src/Pharmacist.Core/Extractors/PlatformExtractors/UWP.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -8,8 +8,6 @@ using NuGet.Frameworks; -using Pharmacist.Core.Groups; -using Pharmacist.Core.NuGet; using Pharmacist.Core.Utilities; namespace Pharmacist.Core.Extractors.PlatformExtractors @@ -20,24 +18,38 @@ namespace Pharmacist.Core.Extractors.PlatformExtractors public class UWP : BasePlatform { /// - public override AutoPlatform Platform => AutoPlatform.UWP; + public override bool CanExtract(NuGetFramework[] frameworks) + { + if (frameworks == null) + { + throw new ArgumentNullException(nameof(frameworks)); + } - /// - public override NuGetFramework Framework { get; } = "uap10.0.16299".ToFrameworks()[0]; + var framework = frameworks[0]; + + return framework.Framework.StartsWith("uap", StringComparison.InvariantCultureIgnoreCase); + } /// - public override Task Extract(string referenceAssembliesLocation) + public override Task Extract(NuGetFramework[] frameworks, string referenceAssembliesLocation) { + if (frameworks == null) + { + throw new ArgumentNullException(nameof(frameworks)); + } + + var framework = frameworks[0]; + if (PlatformHelper.IsRunningOnMono()) { throw new NotSupportedException("Building events for UWP on Mac is not implemented yet."); } - var metadataFile = AssemblyHelpers.FindUnionMetadataFile("Windows", Version.Parse("10.0.16299.0")); + var metadataFile = AssemblyHelpers.FindUnionMetadataFile("Windows", framework.Version); - if (!string.IsNullOrWhiteSpace(metadataFile)) + if (metadataFile != null && !string.IsNullOrWhiteSpace(metadataFile)) { - Input.IncludeGroup.AddFiles(new[] { metadataFile! }); + Input.IncludeGroup.AddFiles(new[] { metadataFile }); } return Task.CompletedTask; diff --git a/src/Pharmacist.Core/Extractors/PlatformExtractors/WPF.cs b/src/Pharmacist.Core/Extractors/PlatformExtractors/WPF.cs index 28f19ad..59adec4 100644 --- a/src/Pharmacist.Core/Extractors/PlatformExtractors/WPF.cs +++ b/src/Pharmacist.Core/Extractors/PlatformExtractors/WPF.cs @@ -1,11 +1,11 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. using System; using System.Collections.Generic; -using System.Threading.Tasks; + using NuGet.Frameworks; namespace Pharmacist.Core.Extractors.PlatformExtractors @@ -13,7 +13,7 @@ namespace Pharmacist.Core.Extractors.PlatformExtractors /// /// WPF platform assemblies and events. /// - internal class WPF : NetCoreExtractorBase + internal class WPF : NetExtractorBase { public WPF(string? filePath) : base(filePath) @@ -21,14 +21,34 @@ public WPF(string? filePath) } /// - public override AutoPlatform Platform => AutoPlatform.WPF; + protected override HashSet WantedFileNames { get; } = new(StringComparer.CurrentCultureIgnoreCase) + { + "WindowsBase.dll", + "PresentationCore.dll", + "PresentationFramework.dll" + }; - /// - protected override HashSet WantedFileNames { get; } = new HashSet(StringComparer.CurrentCultureIgnoreCase) + public override bool CanExtract(NuGetFramework[] frameworks) { - "WindowsBase.dll", - "PresentationCore.dll", - "PresentationFramework.dll" - }; + if (frameworks == null) + { + throw new ArgumentNullException(nameof(frameworks)); + } + + var framework = frameworks[0]; + + if (framework.Framework.Equals(".NETFramework", StringComparison.OrdinalIgnoreCase)) + { + return true; + } + + if (framework.Framework.Equals(".NETCoreApp", StringComparison.OrdinalIgnoreCase) + && framework.Version > new Version(3, 1)) + { + return true; + } + + return framework.Framework.Equals(FrameworkConstants.CommonFrameworks.Net50.Framework); + } } } diff --git a/src/Pharmacist.Core/Extractors/PlatformExtractors/WatchOs.cs b/src/Pharmacist.Core/Extractors/PlatformExtractors/WatchOs.cs new file mode 100644 index 0000000..0b9dec0 --- /dev/null +++ b/src/Pharmacist.Core/Extractors/PlatformExtractors/WatchOs.cs @@ -0,0 +1,57 @@ +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for full license information. + +using System; +using System.Diagnostics.CodeAnalysis; +using System.IO; +using System.Linq; +using System.Threading.Tasks; + +using NuGet.Frameworks; + +using Pharmacist.Core.NuGet; +using Pharmacist.Core.Utilities; + +namespace Pharmacist.Core.Extractors.PlatformExtractors +{ + /// + /// WatchOS platform assemblies and events. + /// + public class WatchOs : BasePlatform + { + /// + public override bool CanExtract(NuGetFramework[] frameworks) + { + if (frameworks == null) + { + throw new ArgumentNullException(nameof(frameworks)); + } + + var framework = frameworks[0]; + + return framework.Framework.StartsWith("Xamarin.WatchOS", StringComparison.InvariantCultureIgnoreCase); + } + + /// + [SuppressMessage( + "Usage", + "CA2249:Consider using 'string.Contains' instead of 'string.IndexOf'", + Justification = "Not supported on all platforms.")] + public override Task Extract(NuGetFramework[] frameworks, string referenceAssembliesLocation) + { + if (frameworks == null) + { + throw new ArgumentNullException(nameof(frameworks)); + } + + var framework = frameworks[0]; + + Input.IncludeGroup.AddFiles( + FileSystemHelpers.GetFilesWithinSubdirectories(framework.GetNuGetFrameworkFolders(), AssemblyHelpers.AssemblyFileExtensionsSet).Where( + x => Path.GetFileName(x).IndexOf("Xamarin.WatchOS", StringComparison.InvariantCultureIgnoreCase) >= 0)); + return Task.CompletedTask; + } + } +} diff --git a/src/Pharmacist.Core/Extractors/PlatformExtractors/Winforms.cs b/src/Pharmacist.Core/Extractors/PlatformExtractors/Winforms.cs index 53cf383..56619ba 100644 --- a/src/Pharmacist.Core/Extractors/PlatformExtractors/Winforms.cs +++ b/src/Pharmacist.Core/Extractors/PlatformExtractors/Winforms.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -6,12 +6,14 @@ using System; using System.Collections.Generic; +using NuGet.Frameworks; + namespace Pharmacist.Core.Extractors.PlatformExtractors { /// /// Win Forms platform assemblies and events. /// - internal class Winforms : NetCoreExtractorBase + internal class Winforms : NetExtractorBase { public Winforms(string? filePath) : base(filePath) @@ -19,14 +21,34 @@ public Winforms(string? filePath) } /// - public override AutoPlatform Platform => AutoPlatform.Winforms; - - /// - protected override HashSet WantedFileNames { get; } = new HashSet(StringComparer.CurrentCultureIgnoreCase) + protected override HashSet WantedFileNames { get; } = new(StringComparer.CurrentCultureIgnoreCase) { "System.DirectoryServices.dll", "System.Windows.Forms.dll", - "System.Drawing.dll", + "System.Drawing.dll" }; + + public override bool CanExtract(NuGetFramework[] frameworks) + { + if (frameworks == null) + { + throw new ArgumentNullException(nameof(frameworks)); + } + + var framework = frameworks[0]; + + if (framework.Framework.Equals(".NETFramework", StringComparison.OrdinalIgnoreCase)) + { + return true; + } + + if (framework.Framework.Equals(".NETCoreApp", StringComparison.OrdinalIgnoreCase) + && framework.Version > new Version(3, 1)) + { + return true; + } + + return framework.Framework.Equals(FrameworkConstants.CommonFrameworks.Net50.Framework); + } } } diff --git a/src/Pharmacist.Core/Extractors/PlatformExtractors/iOS.cs b/src/Pharmacist.Core/Extractors/PlatformExtractors/iOS.cs index fbb6064..c2feaf4 100644 --- a/src/Pharmacist.Core/Extractors/PlatformExtractors/iOS.cs +++ b/src/Pharmacist.Core/Extractors/PlatformExtractors/iOS.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -11,7 +11,6 @@ using NuGet.Frameworks; -using Pharmacist.Core.Groups; using Pharmacist.Core.NuGet; using Pharmacist.Core.Utilities; @@ -25,15 +24,30 @@ namespace Pharmacist.Core.Extractors.PlatformExtractors public class iOS : BasePlatform { /// - public override AutoPlatform Platform => AutoPlatform.iOS; + public override bool CanExtract(NuGetFramework[] frameworks) + { + if (frameworks == null) + { + throw new ArgumentNullException(nameof(frameworks)); + } - /// - public override NuGetFramework Framework { get; } = "Xamarin.iOS10".ToFrameworks()[0]; + var framework = frameworks[0]; + + return framework.Framework.StartsWith("Xamarin.iOS", StringComparison.InvariantCultureIgnoreCase); + } /// - public override Task Extract(string referenceAssembliesLocation) + [SuppressMessage("Usage", "CA2249:Consider using 'string.Contains' instead of 'string.IndexOf'", Justification = "Not supported on all platforms.")] + public override Task Extract(NuGetFramework[] frameworks, string referenceAssembliesLocation) { - Input.IncludeGroup.AddFiles(FileSystemHelpers.GetFilesWithinSubdirectories(Framework.GetNuGetFrameworkFolders(), AssemblyHelpers.AssemblyFileExtensionsSet).Where(x => Path.GetFileName(x).IndexOf("Xamarin.iOS", StringComparison.InvariantCultureIgnoreCase) >= 0)); + if (frameworks == null) + { + throw new ArgumentNullException(nameof(frameworks)); + } + + var framework = frameworks[0]; + + Input.IncludeGroup.AddFiles(FileSystemHelpers.GetFilesWithinSubdirectories(framework.GetNuGetFrameworkFolders(), AssemblyHelpers.AssemblyFileExtensionsSet).Where(x => Path.GetFileName(x).IndexOf("Xamarin.iOS", StringComparison.InvariantCultureIgnoreCase) >= 0)); return Task.CompletedTask; } } diff --git a/src/Pharmacist.Core/Extractors/PlatformExtractors/tvOS.cs b/src/Pharmacist.Core/Extractors/PlatformExtractors/tvOS.cs index f720293..35ea7a8 100644 --- a/src/Pharmacist.Core/Extractors/PlatformExtractors/tvOS.cs +++ b/src/Pharmacist.Core/Extractors/PlatformExtractors/tvOS.cs @@ -1,16 +1,16 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. using System; +using System.Diagnostics.CodeAnalysis; using System.IO; using System.Linq; using System.Threading.Tasks; using NuGet.Frameworks; -using Pharmacist.Core.Groups; using Pharmacist.Core.NuGet; using Pharmacist.Core.Utilities; @@ -22,16 +22,30 @@ namespace Pharmacist.Core.Extractors.PlatformExtractors public class TVOS : BasePlatform { /// - public override AutoPlatform Platform => AutoPlatform.TVOS; + public override bool CanExtract(NuGetFramework[] frameworks) + { + if (frameworks == null) + { + throw new ArgumentNullException(nameof(frameworks)); + } - /// - public override NuGetFramework Framework { get; } = "Xamarin.TVOS10".ToFrameworks()[0]; + var framework = frameworks[0]; + + return framework.Framework.StartsWith("Xamarin.TVOS", StringComparison.InvariantCultureIgnoreCase); + } /// - public override Task Extract(string referenceAssembliesLocation) + [SuppressMessage("Usage", "CA2249:Consider using 'string.Contains' instead of 'string.IndexOf'", Justification = "Not supported on all platforms.")] + public override Task Extract(NuGetFramework[] frameworks, string referenceAssembliesLocation) { - Input.IncludeGroup.AddFiles(FileSystemHelpers.GetFilesWithinSubdirectories(Framework.GetNuGetFrameworkFolders(), AssemblyHelpers.AssemblyFileExtensionsSet).Where(x => Path.GetFileName(x).IndexOf("Xamarin.TVOS", StringComparison.InvariantCultureIgnoreCase) >= 0)); + if (frameworks == null) + { + throw new ArgumentNullException(nameof(frameworks)); + } + + var framework = frameworks[0]; + Input.IncludeGroup.AddFiles(FileSystemHelpers.GetFilesWithinSubdirectories(framework.GetNuGetFrameworkFolders(), AssemblyHelpers.AssemblyFileExtensionsSet).Where(x => Path.GetFileName(x).IndexOf("Xamarin.TVOS", StringComparison.InvariantCultureIgnoreCase) >= 0)); return Task.CompletedTask; } } diff --git a/src/Pharmacist.Core/Generation/Compilation/EventBuilderCompiler.cs b/src/Pharmacist.Core/Generation/Compilation/EventBuilderCompiler.cs index d093c1e..182aa8b 100644 --- a/src/Pharmacist.Core/Generation/Compilation/EventBuilderCompiler.cs +++ b/src/Pharmacist.Core/Generation/Compilation/EventBuilderCompiler.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -32,9 +32,8 @@ namespace Pharmacist.Core.Generation.Compilation internal sealed class EventBuilderCompiler : ICompilation, IDisposable { private readonly KnownTypeCache _knownTypeCache; - private readonly List _assemblies = new List(); - private readonly List _referencedAssemblies = new List(); - private readonly INamespace _rootNamespace; + private readonly List _assemblies = new(); + private readonly List _referencedAssemblies = new(); public EventBuilderCompiler(InputAssembliesGroup input, NuGetFramework framework) { @@ -53,14 +52,14 @@ public EventBuilderCompiler(InputAssembliesGroup input, NuGetFramework framework _assemblies.AddRange(moduleReferences.Select(x => x.Resolve(context))); _referencedAssemblies.AddRange(GetReferenceModules(_assemblies, input, framework, context)); - _rootNamespace = CreateRootNamespace(); + RootNamespace = CreateRootNamespace(); } /// /// Gets the main module we are extracting information from. /// This is mostly just here due to ILDecompile needing it. /// - public IModule MainModule + public IModule? MainModule { get { @@ -94,33 +93,21 @@ public IReadOnlyList ReferencedModules /// /// Gets the root namespace for our assemblies. We can start analyzing from here. /// - public INamespace RootNamespace - { - get - { - return _rootNamespace; - } - } + public INamespace RootNamespace { get; } /// - /// Gets the comparer we are going to use for comparing names of items. We just compare ordinally. + /// Gets the comparer we are going to use for comparing names of items. /// public StringComparer NameComparer => StringComparer.Ordinal; /// /// Gets the cache manager. This is mostly here for ILDecompile. /// - public CacheManager CacheManager { get; } = new CacheManager(); + public CacheManager CacheManager { get; } = new(); public INamespace? GetNamespaceForExternAlias(string alias) { - if (string.IsNullOrEmpty(alias)) - { - return RootNamespace; - } - - // SimpleCompilation does not support extern aliases; but derived classes might. - return null; + return string.IsNullOrEmpty(alias) ? RootNamespace : null; } public IType FindType(KnownTypeCode typeCode) @@ -149,15 +136,15 @@ private static IEnumerable GetReferenceModules(IEnumerable mai var referenceModulesToProcess = new Stack<(IModule Parent, IAssemblyReference Reference)>(mainModules.SelectMany(x => x.PEFile.AssemblyReferences.Select(reference => (x, (IAssemblyReference)reference)))); while (referenceModulesToProcess.Count > 0) { - var current = referenceModulesToProcess.Pop(); + var (parent, reference) = referenceModulesToProcess.Pop(); - if (!assemblyReferencesSeen.Add(current.Reference)) + if (!assemblyReferencesSeen.Add(reference)) { continue; } #pragma warning disable CA2000 // Dispose objects before losing scope - var moduleReference = (IModuleReference?)current.Reference.Resolve(current.Parent, input, framework); + var moduleReference = (IModuleReference?)reference.Resolve(parent, input, framework); #pragma warning restore CA2000 // Dispose objects before losing scope if (moduleReference == null) @@ -184,10 +171,7 @@ private INamespace CreateRootNamespace() // SimpleCompilation does not support extern aliases; but derived classes might. // CreateRootNamespace() is virtual so that derived classes can change the global namespace. namespaces.Add(module.RootNamespace); - for (var i = 0; i < _referencedAssemblies.Count; i++) - { - namespaces.Add(_referencedAssemblies[i].RootNamespace); - } + namespaces.AddRange(_referencedAssemblies.Select(assembly => assembly.RootNamespace)); } return new MergedNamespace(this, namespaces.ToArray()); diff --git a/src/Pharmacist.Core/Generation/Compilation/KnownTypeCache.cs b/src/Pharmacist.Core/Generation/Compilation/KnownTypeCache.cs index 9f799c1..bfff367 100644 --- a/src/Pharmacist.Core/Generation/Compilation/KnownTypeCache.cs +++ b/src/Pharmacist.Core/Generation/Compilation/KnownTypeCache.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -27,12 +27,7 @@ public KnownTypeCache(ICompilation compilation) public IType FindType(KnownTypeCode typeCode) { var type = LazyInit.VolatileRead(ref _knownTypes[(int)typeCode]); - if (type != null) - { - return type; - } - - return LazyInit.GetOrSet(ref _knownTypes[(int)typeCode], SearchType(typeCode)); + return type ?? LazyInit.GetOrSet(ref _knownTypes[(int)typeCode], SearchType(typeCode)); } private IType SearchType(KnownTypeCode typeCode) diff --git a/src/Pharmacist.Core/Generation/Compilation/PathSearchExtensions.cs b/src/Pharmacist.Core/Generation/Compilation/PathSearchExtensions.cs index 4ad9655..5dfbadd 100644 --- a/src/Pharmacist.Core/Generation/Compilation/PathSearchExtensions.cs +++ b/src/Pharmacist.Core/Generation/Compilation/PathSearchExtensions.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -6,6 +6,7 @@ using System; using System.Collections.Generic; using System.IO; +using System.Linq; using System.Reflection.PortableExecutable; using System.Runtime.InteropServices; @@ -35,12 +36,7 @@ internal static class PathSearchExtensions { var fileName = GetFileName(reference, parent, input, framework); - if (string.IsNullOrWhiteSpace(fileName)) - { - return null; - } - - return new PEFile(fileName, parameters); + return string.IsNullOrWhiteSpace(fileName) ? null : new PEFile(fileName, parameters); } private static string? GetFileName(IAssemblyReference reference, IModule parent, InputAssembliesGroup input, NuGetFramework framework) @@ -72,88 +68,31 @@ internal static class PathSearchExtensions file = SearchDirectories(reference, input, extensions); - if (!string.IsNullOrWhiteSpace(file)) - { - return file; - } - - return SearchNugetFrameworkDirectories(reference, extensions, framework); + return !string.IsNullOrWhiteSpace(file) ? file : SearchNugetFrameworkDirectories(reference, extensions, framework); } private static string? FindInParentDirectory(IAssemblyReference reference, IModule parent, IEnumerable extensions) { - if (parent == null) - { - return null; - } - var baseDirectory = Path.GetDirectoryName(parent.PEFile.FileName); - if (string.IsNullOrWhiteSpace(baseDirectory)) + if (baseDirectory == null || string.IsNullOrWhiteSpace(baseDirectory)) { return null; } - foreach (var extension in extensions) - { - var moduleFileName = Path.Combine(baseDirectory, reference.Name + extension); - if (!File.Exists(moduleFileName)) - { - continue; - } - - return moduleFileName; - } - - return null; + return extensions.Select(extension => Path.Combine(baseDirectory, reference.Name + extension)).FirstOrDefault(File.Exists); } private static string? SearchNugetFrameworkDirectories(IAssemblyReference reference, IReadOnlyCollection extensions, NuGetFramework framework) { var folders = framework.GetNuGetFrameworkFolders(); - foreach (var folder in folders) - { - foreach (var extension in extensions) - { - var testName = Path.Combine(folder, reference.Name + extension); - - if (string.IsNullOrWhiteSpace(testName)) - { - continue; - } - - if (!File.Exists(testName)) - { - continue; - } - - return testName; - } - } - - return null; + return folders.SelectMany(_ => extensions, (folder, extension) => Path.Combine(folder, reference.Name + extension)).Where(testName => !string.IsNullOrWhiteSpace(testName)).FirstOrDefault(File.Exists); } private static string? SearchDirectories(IAssemblyReference name, InputAssembliesGroup input, IEnumerable extensions) { - foreach (var extension in extensions) - { - var testName = input.SupportGroup.GetFullFilePath(name.Name + extension); - if (string.IsNullOrWhiteSpace(testName)) - { - continue; - } - - if (!File.Exists(testName)) - { - continue; - } - - return testName; - } - - return null; + return extensions.Select(extension => input.SupportGroup.GetFullFilePath(name.Name + extension)).Where(testName => !string.IsNullOrWhiteSpace(testName)).FirstOrDefault(File.Exists); } private static string? GetCorlib(IAssemblyReference reference) @@ -166,15 +105,9 @@ internal static class PathSearchExtensions return typeof(object).Module.FullyQualifiedName; } - string? path; - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) - { - path = GetMscorlibBasePath(version, reference.PublicKeyToken.ToHexString(8)); - } - else - { - path = GetMonoMscorlibBasePath(version); - } + var path = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? + GetMscorlibBasePath(version, reference.PublicKeyToken.ToHexString(8)) : + GetMonoMscorlibBasePath(version); if (path == null) { @@ -182,34 +115,20 @@ internal static class PathSearchExtensions } var file = Path.Combine(path, "mscorlib.dll"); - if (File.Exists(file)) - { - return file; - } - - return null; + return File.Exists(file) ? file : null; } private static string? GetMscorlibBasePath(Version version, string publicKeyToken) { string? GetSubFolderForVersion() { - switch (version.Major) + return version.Major switch { - case 1: - if (version.MajorRevision == 3300) - { - return "v1.0.3705"; - } - - return "v1.1.4322"; - case 2: - return "v2.0.50727"; - case 4: - return "v4.0.30319"; - default: - return null; - } + 1 => version.MajorRevision == 3300 ? "v1.0.3705" : "v1.1.4322", + 2 => "v2.0.50727", + 4 => "v4.0.30319", + _ => null + }; } if (publicKeyToken == "969db8053d3322ac") @@ -235,17 +154,7 @@ internal static class PathSearchExtensions var folder = GetSubFolderForVersion(); - if (folder != null) - { - foreach (var path in frameworkPaths) - { - var basePath = Path.Combine(path, folder); - if (Directory.Exists(basePath)) - { - return basePath; - } - } - } + return folder == null ? null : frameworkPaths.Select(path => Path.Combine(path, folder)).FirstOrDefault(Directory.Exists); } return null; @@ -253,39 +162,25 @@ internal static class PathSearchExtensions private static string? GetMonoMscorlibBasePath(Version version) { - var path = Directory.GetParent(typeof(object).Module.FullyQualifiedName).Parent?.FullName; + var moduleName = typeof(object).Module.FullyQualifiedName; - if (string.IsNullOrWhiteSpace(path)) - { - return null; - } + var path = Directory.GetParent(moduleName)?.Parent?.FullName; - if (version.Major == 1) - { - path = Path.Combine(path, "1.0"); - } - else if (version.Major == 2) - { - if (version.MajorRevision == 5) - { - path = Path.Combine(path, "2.1"); - } - else - { - path = Path.Combine(path, "2.0"); - } - } - else if (version.Major == 4) + if (path is null || string.IsNullOrWhiteSpace(path)) { - path = Path.Combine(path, "4.0"); + return null; } - if (Directory.Exists(path)) + path = version.Major switch { - return path; - } + 1 => Path.Combine(path, "1.0"), + 2 when version.MajorRevision == 5 => Path.Combine(path, "2.1"), + 2 => Path.Combine(path, "2.0"), + 4 => Path.Combine(path, "4.0"), + _ => path + }; - return null; + return Directory.Exists(path) ? path : null; } private static bool IsSpecialVersionOrRetargetable(IAssemblyReference reference) diff --git a/src/Pharmacist.Core/Generation/EventNameComparer.cs b/src/Pharmacist.Core/Generation/EventNameComparer.cs index 8e4a519..9d41d16 100644 --- a/src/Pharmacist.Core/Generation/EventNameComparer.cs +++ b/src/Pharmacist.Core/Generation/EventNameComparer.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -11,16 +11,39 @@ namespace Pharmacist.Core.Generation { internal class EventNameComparer : IComparer, IEqualityComparer { - public static EventNameComparer Default { get; } = new EventNameComparer(); + public static EventNameComparer Default { get; } = new(); - public int Compare(IEvent x, IEvent y) + public int Compare(IEvent? x, IEvent? y) { - return string.Compare(x.Name, y.Name, StringComparison.InvariantCulture); + switch (x) + { + case null when y == null: + return 0; + case null: + return 1; + } + + if (y == null) + { + return -1; + } + + return ReferenceEquals(x, y) ? 0 : string.Compare(x.Name, y.Name, StringComparison.InvariantCulture); } - public bool Equals(IEvent x, IEvent y) + public bool Equals(IEvent? x, IEvent? y) { - return string.Equals(x.Name, y.Name, StringComparison.InvariantCulture); + if (x == null && y == null) + { + return true; + } + + if (x == null || y == null) + { + return false; + } + + return ReferenceEquals(x, y) || string.Equals(x.Name, y.Name, StringComparison.InvariantCulture); } public int GetHashCode(IEvent obj) diff --git a/src/Pharmacist.Core/Generation/Generators/DelegateGenerator.cs b/src/Pharmacist.Core/Generation/Generators/DelegateGenerator.cs index 042eff6..d05d94e 100644 --- a/src/Pharmacist.Core/Generation/Generators/DelegateGenerator.cs +++ b/src/Pharmacist.Core/Generation/Generators/DelegateGenerator.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -129,7 +129,6 @@ private static FieldDeclarationSyntax GenerateFieldDeclaration(string observable private static MethodDeclarationSyntax GenerateMethodDeclaration(string observableName, IMethod method) { // Produces: - // /// // public override void MethodName(params..) => _methodName.OnNext(...); var methodBody = InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, IdentifierName(observableName), IdentifierName("OnNext"))); @@ -140,14 +139,9 @@ private static MethodDeclarationSyntax GenerateMethodDeclaration(string observab { // If we have only one member, just pass that directly, since our observable will have one generic type parameter. // If we have more than one parameter we have to pass them by value tuples, since observables only have one generic type parameter. - if (method.Parameters.Count == 1) - { - methodBody = methodBody.WithArgumentList(method.Parameters[0].GenerateArgumentList()); - } - else - { - methodBody = methodBody.WithArgumentList(method.Parameters.GenerateTupleArgumentList()); - } + methodBody = methodBody.WithArgumentList(method.Parameters.Count == 1 ? + method.Parameters[0].GenerateArgumentList() : + method.Parameters.GenerateTupleArgumentList()); } else { diff --git a/src/Pharmacist.Core/Generation/Generators/EventGeneratorBase.cs b/src/Pharmacist.Core/Generation/Generators/EventGeneratorBase.cs index 348d3cf..6aeedde 100644 --- a/src/Pharmacist.Core/Generation/Generators/EventGeneratorBase.cs +++ b/src/Pharmacist.Core/Generation/Generators/EventGeneratorBase.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -36,7 +36,7 @@ internal abstract class EventGeneratorBase : IEventGenerator /// The name of the item where the event is stored. /// A prefix to append to the name. /// The property declaration. - protected static PropertyDeclarationSyntax? GenerateEventWrapperObservable(IEvent eventDetails, string dataObjectName, string? prefix = null) + protected static PropertyDeclarationSyntax GenerateEventWrapperObservable(IEvent eventDetails, string dataObjectName, string? prefix = null) { prefix ??= string.Empty; @@ -45,11 +45,6 @@ internal abstract class EventGeneratorBase : IEventGenerator // Create "Observable.FromEvent" for our method. var (expressionBody, observableEventArgType) = GenerateFromEventExpression(eventDetails, invokeMethod, dataObjectName); - if (observableEventArgType == null || expressionBody == null) - { - return null; - } - var modifiers = eventDetails.IsStatic ? TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword)) : TokenList(Token(SyntaxKind.PublicKeyword)); @@ -64,32 +59,32 @@ internal abstract class EventGeneratorBase : IEventGenerator .WithLeadingTrivia(GenerateSummarySeeAlsoComment("Gets an observable which signals when the {0} event triggers.", eventDetails.ConvertToDocument())); } - private static (ArrowExpressionClauseSyntax ArrowClause, TypeSyntax EventArgsType) GenerateFromEventExpression(IEvent eventDetails, IMethod invokeMethod, string dataObjectName) + private static (ArrowExpressionClauseSyntax ArrowClause, TypeSyntax EventArgsType) GenerateFromEventExpression(IMember eventDetails, IMethod invokeMethod, string dataObjectName) { var returnType = IdentifierName(eventDetails.ReturnType.GenerateFullGenericName()); ArgumentListSyntax methodParametersArgumentList; TypeSyntax eventArgsType; - // If we are using a standard approach of using 2 parameters only send the "Value", not the sender. - if (invokeMethod.Parameters.Count == 2 && invokeMethod.Parameters[0].Type.FullName == "System.Object") - { - methodParametersArgumentList = invokeMethod.Parameters[1].GenerateArgumentList(); - eventArgsType = IdentifierName(invokeMethod.Parameters[1].Type.GenerateFullGenericName()); - } - else if (invokeMethod.Parameters.Count > 0) - { - // If we have any members call our observables with the parameters. - // If we have only one member, produces arguments: (arg1); - // If we have greater than one member, produces arguments with value type: ((arg1, arg2)) - methodParametersArgumentList = invokeMethod.Parameters.Count == 1 ? invokeMethod.Parameters[0].GenerateArgumentList() : invokeMethod.Parameters.GenerateTupleArgumentList(); - eventArgsType = invokeMethod.Parameters.Count == 1 ? IdentifierName(invokeMethod.Parameters[0].Type.GenerateFullGenericName()) : invokeMethod.Parameters.Select(x => (x.Type, x.Name)).GenerateTupleType(); - } - else + switch (invokeMethod.Parameters.Count) { - // Produces argument: (global::System.Reactive.Unit.Default) - methodParametersArgumentList = RoslynHelpers.ReactiveUnitArgumentList; - eventArgsType = IdentifierName(RoslynHelpers.ObservableUnitName); + // If we are using a standard approach of using 2 parameters only send the "Value", not the sender. + case 2 when invokeMethod.Parameters[0].Type.FullName == "System.Object": + methodParametersArgumentList = invokeMethod.Parameters[1].GenerateArgumentList(); + eventArgsType = IdentifierName(invokeMethod.Parameters[1].Type.GenerateFullGenericName()); + break; + case > 0: + // If we have any members call our observables with the parameters. + // If we have only one member, produces arguments: (arg1); + // If we have greater than one member, produces arguments with value type: ((arg1, arg2)) + methodParametersArgumentList = invokeMethod.Parameters.Count == 1 ? invokeMethod.Parameters[0].GenerateArgumentList() : invokeMethod.Parameters.GenerateTupleArgumentList(); + eventArgsType = invokeMethod.Parameters.Count == 1 ? IdentifierName(invokeMethod.Parameters[0].Type.GenerateFullGenericName()) : invokeMethod.Parameters.Select(x => (x.Type, x.Name)).GenerateTupleType(); + break; + default: + // Produces argument: (global::System.Reactive.Unit.Default) + methodParametersArgumentList = RoslynHelpers.ReactiveUnitArgumentList; + eventArgsType = IdentifierName(RoslynHelpers.ObservableUnitName); + break; } var eventName = eventDetails.Name; diff --git a/src/Pharmacist.Core/Generation/Generators/IEventGenerator.cs b/src/Pharmacist.Core/Generation/Generators/IEventGenerator.cs index 6db0186..fe9598e 100644 --- a/src/Pharmacist.Core/Generation/Generators/IEventGenerator.cs +++ b/src/Pharmacist.Core/Generation/Generators/IEventGenerator.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.Core/Generation/Generators/InstanceEventGenerator.cs b/src/Pharmacist.Core/Generation/Generators/InstanceEventGenerator.cs index 749d219..57a15d4 100644 --- a/src/Pharmacist.Core/Generation/Generators/InstanceEventGenerator.cs +++ b/src/Pharmacist.Core/Generation/Generators/InstanceEventGenerator.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -30,7 +30,7 @@ public override IEnumerable Generate(IEnumerable<(IT var orderedTypeDeclarations = groupedDeclarations.OrderBy(x => x.TypeDefinition.Name).ToList(); members.Add(GenerateStaticClass(namespaceName, orderedTypeDeclarations.Select(x => x.TypeDefinition))); - members.AddRange(orderedTypeDeclarations.Select(x => GenerateEventWrapperClass(x.TypeDefinition, x.BaseDefinition, x.Events)).Where(x => x != null)); + members.AddRange(orderedTypeDeclarations.Select(x => GenerateEventWrapperClass(x.TypeDefinition, x.BaseDefinition, x.Events))); if (members.Count > 0) { @@ -89,7 +89,7 @@ static MethodDeclarationSyntax BuildMethodDeclaration(ITypeDefinition declaratio private static ConstructorDeclarationSyntax GenerateEventWrapperClassConstructor(ITypeDefinition typeDefinition, bool hasBaseClass) { - const string dataParameterName = "data"; + const string DataParameterName = "data"; var constructor = ConstructorDeclaration( Identifier("Rx" + typeDefinition.Name + "Events")) .WithModifiers( @@ -99,23 +99,23 @@ private static ConstructorDeclarationSyntax GenerateEventWrapperClassConstructor ParameterList( SingletonSeparatedList( Parameter( - Identifier(dataParameterName)) + Identifier(DataParameterName)) .WithType( IdentifierName(typeDefinition.GenerateFullGenericName()))))) .WithBody(Block(SingletonList( ExpressionStatement( AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, IdentifierName(DataFieldName), IdentifierName("data")))))) - .WithLeadingTrivia(XmlSyntaxFactory.GenerateSummarySeeAlsoComment("Initializes a new instance of the {0} class.", typeDefinition.ConvertToDocument(), (dataParameterName, "The class that is being wrapped."))); + .WithLeadingTrivia(XmlSyntaxFactory.GenerateSummarySeeAlsoComment("Initializes a new instance of the {0} class.", typeDefinition.ConvertToDocument(), (DataParameterName, "The class that is being wrapped."))); if (hasBaseClass) { - constructor = constructor.WithInitializer(ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, ArgumentList(SingletonSeparatedList(Argument(IdentifierName(dataParameterName)))))); + constructor = constructor.WithInitializer(ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, ArgumentList(SingletonSeparatedList(Argument(IdentifierName(DataParameterName)))))); } return constructor; } - private static FieldDeclarationSyntax GenerateEventWrapperField(ITypeDefinition typeDefinition) + private static FieldDeclarationSyntax GenerateEventWrapperField(IType typeDefinition) { return FieldDeclaration(VariableDeclaration(IdentifierName(typeDefinition.GenerateFullGenericName())) .WithVariables(SingletonSeparatedList(VariableDeclarator(Identifier(DataFieldName))))) @@ -125,7 +125,7 @@ private static FieldDeclarationSyntax GenerateEventWrapperField(ITypeDefinition private static ClassDeclarationSyntax GenerateEventWrapperClass(ITypeDefinition typeDefinition, ITypeDefinition? baseTypeDefinition, IEnumerable events) { var members = new List { GenerateEventWrapperField(typeDefinition), GenerateEventWrapperClassConstructor(typeDefinition, baseTypeDefinition != null) }; - members.AddRange(events.OrderBy(x => x.Name).Select(x => GenerateEventWrapperObservable(x, DataFieldName)).Where(x => x != null).Select(x => x!)); + members.AddRange(events.OrderBy(x => x.Name).Select(x => GenerateEventWrapperObservable(x, DataFieldName)).Select(x => x!)); var classDeclaration = ClassDeclaration("Rx" + typeDefinition.Name + "Events") .WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword))) @@ -141,23 +141,25 @@ private static ClassDeclarationSyntax GenerateEventWrapperClass(ITypeDefinition Token(SyntaxKind.GreaterThanToken))); } - if (baseTypeDefinition != null) + if (baseTypeDefinition == null) { - var baseTypeName = $"global::{baseTypeDefinition.Namespace}.Rx{baseTypeDefinition.Name}Events"; - if (baseTypeDefinition.IsUnboundGenericTypeDefinition()) - { - var directBaseType = typeDefinition.DirectBaseTypes - .First(directBase => directBase.FullName == baseTypeDefinition.FullName); - var argumentList = directBaseType.TypeArguments.Select(arg => arg.GenerateFullGenericName()); - var argumentString = "<" + string.Join(", ", argumentList) + ">"; - baseTypeName += argumentString; - } + return classDeclaration; + } - classDeclaration = classDeclaration.WithBaseList(BaseList( - SingletonSeparatedList(SimpleBaseType( - IdentifierName(baseTypeName))))); + var baseTypeName = $"global::{baseTypeDefinition.Namespace}.Rx{baseTypeDefinition.Name}Events"; + if (baseTypeDefinition.IsUnboundGenericTypeDefinition()) + { + var directBaseType = typeDefinition.DirectBaseTypes + .First(directBase => directBase.FullName == baseTypeDefinition.FullName); + var argumentList = directBaseType.TypeArguments.Select(arg => arg.GenerateFullGenericName()); + var argumentString = "<" + string.Join(", ", argumentList) + ">"; + baseTypeName += argumentString; } + classDeclaration = classDeclaration.WithBaseList(BaseList( + SingletonSeparatedList(SimpleBaseType( + IdentifierName(baseTypeName))))); + return classDeclaration; } } diff --git a/src/Pharmacist.Core/Generation/Generators/StaticEventGenerator.cs b/src/Pharmacist.Core/Generation/Generators/StaticEventGenerator.cs index 378dee4..a57541f 100644 --- a/src/Pharmacist.Core/Generation/Generators/StaticEventGenerator.cs +++ b/src/Pharmacist.Core/Generation/Generators/StaticEventGenerator.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -36,20 +36,21 @@ public override IEnumerable Generate(IEnumerable<(IT x => x.Events .OrderBy(eventDetails => eventDetails.Name) - .Select(eventDetails => GenerateEventWrapperObservable(eventDetails, x.TypeDefinition.GenerateFullGenericName(), x.TypeDefinition.Name)) - .Where(y => y != null)) + .Select(eventDetails => GenerateEventWrapperObservable(eventDetails, x.TypeDefinition.GenerateFullGenericName(), x.TypeDefinition.Name))) .ToList(); - if (eventWrapperMembers.Count > 0) + if (eventWrapperMembers.Count == 0) { - var members = ClassDeclaration("Events") - .WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword))) - .WithLeadingTrivia(GenerateSummarySeeAlsoComment("A class that contains extension methods to wrap events contained within static classes within the {0} namespace.", namespaceName)) - .WithMembers(List(eventWrapperMembers.Where(x => x != null).Select(x => x!))); - - yield return NamespaceDeclaration(IdentifierName(namespaceName)) - .WithMembers(SingletonList(members)); + continue; } + + var members = ClassDeclaration("Events") + .WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword))) + .WithLeadingTrivia(GenerateSummarySeeAlsoComment("A class that contains extension methods to wrap events contained within static classes within the {0} namespace.", namespaceName)) + .WithMembers(List(eventWrapperMembers.Select(x => x!))); + + yield return NamespaceDeclaration(IdentifierName(namespaceName)) + .WithMembers(SingletonList(members)); } } } diff --git a/src/Pharmacist.Core/Generation/ReflectionExtensions.cs b/src/Pharmacist.Core/Generation/ReflectionExtensions.cs index a7f7251..a463f2f 100644 --- a/src/Pharmacist.Core/Generation/ReflectionExtensions.cs +++ b/src/Pharmacist.Core/Generation/ReflectionExtensions.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -21,9 +21,9 @@ namespace Pharmacist.Core.Generation /// internal static class ReflectionExtensions { - private static readonly ConcurrentDictionary>> _typeNameMapping = new ConcurrentDictionary>>(); - private static readonly ConcurrentDictionary> _publicNonGenericTypeMapping = new ConcurrentDictionary>(); - private static readonly ConcurrentDictionary> _publicEventsTypeMapping = new ConcurrentDictionary>(); + private static readonly ConcurrentDictionary>> _typeNameMapping = new(); + private static readonly ConcurrentDictionary> _publicNonGenericTypeMapping = new(); + private static readonly ConcurrentDictionary> _publicEventsTypeMapping = new(); /// /// Get all type definitions where they have public events, aren't generic (no type parameters == 0), and they are public. @@ -103,21 +103,13 @@ public static IEnumerable GetPublicTypeDefinitions(this ICompil var compilation = eventDetails.Compilation; // Find the EventArgs type parameter of the event via digging around via reflection - if (!eventDetails.CanAdd || !eventDetails.CanRemove) + if (eventDetails.CanAdd && eventDetails.CanRemove) { - LogHost.Default.Debug($"Type for {eventDetails.DeclaringType.FullName} is not valid"); - return null; + return GetRealType(eventDetails.ReturnType, compilation); } - var type = GetRealType(eventDetails.ReturnType, compilation); - - if (type == null) - { - LogHost.Default.Debug($"Type for {eventDetails.DeclaringType.FullName} is not valid"); - return null; - } - - return type; + LogHost.Default.Debug($"Type for {eventDetails.DeclaringType.FullName} is not valid"); + return null; } /// @@ -134,20 +126,22 @@ public static IType GetRealType(this IType type, ICompilation compilation) // since UnknownType is only if it's unknown in the current assembly only. // This scenario is fairly common with types in the netstandard libraries, eg System.EventHandler. var newType = type; - if (newType is UnknownType || newType.Kind == TypeKind.Unknown) + if (newType is not UnknownType && newType.Kind != TypeKind.Unknown) { - if (newType.TypeParameterCount == 0) - { - newType = compilation.GetReferenceTypeDefinitionsWithFullName(newType.ReflectionName).FirstOrDefault(); - } - else if (newType is ParameterizedType paramType) - { - var genericType = compilation.GetReferenceTypeDefinitionsWithFullName(paramType.GenericType.ReflectionName).FirstOrDefault(); + return newType; + } - var typeArguments = newType.TypeArguments.Select(x => GetRealType(x, compilation)); + if (newType.TypeParameterCount == 0) + { + newType = compilation.GetReferenceTypeDefinitionsWithFullName(newType.ReflectionName).FirstOrDefault(); + } + else if (newType is ParameterizedType paramType) + { + var genericType = compilation.GetReferenceTypeDefinitionsWithFullName(paramType.GenericType.ReflectionName).FirstOrDefault(); + + var typeArguments = newType.TypeArguments.Select(x => GetRealType(x, compilation)); - newType = new ParameterizedType(genericType, typeArguments); - } + newType = new ParameterizedType(genericType, typeArguments); } return newType ?? type; @@ -163,15 +157,17 @@ public static string GenerateFullGenericName(this IType currentType) var (isBuiltIn, typeName) = GetBuiltInType(currentType.FullName); var sb = new StringBuilder(!isBuiltIn ? "global::" + typeName : typeName); - if (currentType.TypeParameterCount > 0) + if (currentType.TypeParameterCount <= 0) { - var isUnbound = currentType.IsUnbound(); - var arguments = string.Join(", ", currentType.TypeArguments.Select(GenerateName)); - sb.Append('<').Append(arguments).Append('>'); - - string GenerateName(IType type) => isUnbound ? type.FullName : GenerateFullGenericName(type); + return sb.ToString(); } + var isUnbound = currentType.IsUnbound(); + var arguments = string.Join(", ", currentType.TypeArguments.Select(GenerateName)); + sb.Append('<').Append(arguments).Append('>'); + + string GenerateName(IType type) => isUnbound ? type.FullName : GenerateFullGenericName(type); + return sb.ToString(); } @@ -200,12 +196,7 @@ private static IEnumerable GetPublicTypeDefinitionsWithEvents(I private static (bool IsInternalType, string TypeName) GetBuiltInType(string typeName) { - if (TypesMetadata.FullToBuiltInTypes.TryGetValue(typeName, out var builtInName)) - { - return (true, builtInName); - } - - return (false, typeName); + return TypesMetadata.FullToBuiltInTypes.TryGetValue(typeName, out var builtInName) ? (true, builtInName) : (false, typeName); } } } diff --git a/src/Pharmacist.Core/Generation/Resolvers/DelegateTemplateNamespaceResolver.cs b/src/Pharmacist.Core/Generation/Resolvers/DelegateTemplateNamespaceResolver.cs index 1992194..96a1e37 100644 --- a/src/Pharmacist.Core/Generation/Resolvers/DelegateTemplateNamespaceResolver.cs +++ b/src/Pharmacist.Core/Generation/Resolvers/DelegateTemplateNamespaceResolver.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -38,7 +38,7 @@ public IEnumerable Create(ICompilation compilation) IEnumerable<(ITypeDefinition TypeDefinition, bool IsAbstract, IEnumerable Methods)> values = compilation.GetPublicTypeDefinitions() .Where( x => x.Kind != TypeKind.Interface - && (!IsMulticastDelegateDerived(x) + && (!IsMultiCastDelegateDerived(x) || !x.DirectBaseTypes.Any()) && !_garbageTypeList.Any(y => x.FullName.Contains(y)) && CocoaDelegateNames.Any(cocoaName => x.FullName.EndsWith(cocoaName, StringComparison.OrdinalIgnoreCase))) @@ -49,7 +49,7 @@ public IEnumerable Create(ICompilation compilation) return DelegateGenerator.Generate(values); } - private static bool IsMulticastDelegateDerived(ITypeDefinition typeDefinition) + private static bool IsMultiCastDelegateDerived(IType typeDefinition) { return typeDefinition.DirectBaseTypes.Any(x => x.FullName.Contains(DelegateName)); } diff --git a/src/Pharmacist.Core/Generation/Resolvers/EventNamespaceResolverBase.cs b/src/Pharmacist.Core/Generation/Resolvers/EventNamespaceResolverBase.cs index e0b3336..8998589 100644 --- a/src/Pharmacist.Core/Generation/Resolvers/EventNamespaceResolverBase.cs +++ b/src/Pharmacist.Core/Generation/Resolvers/EventNamespaceResolverBase.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.Core/Generation/Resolvers/INamespaceResolver.cs b/src/Pharmacist.Core/Generation/Resolvers/INamespaceResolver.cs index 23826a1..151df2b 100644 --- a/src/Pharmacist.Core/Generation/Resolvers/INamespaceResolver.cs +++ b/src/Pharmacist.Core/Generation/Resolvers/INamespaceResolver.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.Core/Generation/Resolvers/PublicEventNamespaceResolver.cs b/src/Pharmacist.Core/Generation/Resolvers/PublicEventNamespaceResolver.cs index 40e8f33..28fc087 100644 --- a/src/Pharmacist.Core/Generation/Resolvers/PublicEventNamespaceResolver.cs +++ b/src/Pharmacist.Core/Generation/Resolvers/PublicEventNamespaceResolver.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -6,7 +6,6 @@ using System; using System.Collections.Concurrent; using System.Collections.Generic; -using System.Diagnostics; using System.Linq; using System.Threading.Tasks; @@ -93,7 +92,7 @@ protected override IEventGenerator GetEventGenerator() return new InstanceEventGenerator(); } - private static ITypeDefinition? GetValidBaseType(ITypeDefinition typeDefinition, ICompilation compilation) + private static ITypeDefinition? GetValidBaseType(IType typeDefinition, ICompilation compilation) { var processedTypes = new HashSet(); var processingQueue = new Queue(typeDefinition.DirectBaseTypes); diff --git a/src/Pharmacist.Core/Generation/Resolvers/PublicStaticEventNamespaceResolver.cs b/src/Pharmacist.Core/Generation/Resolvers/PublicStaticEventNamespaceResolver.cs index 238e94a..dfefc06 100644 --- a/src/Pharmacist.Core/Generation/Resolvers/PublicStaticEventNamespaceResolver.cs +++ b/src/Pharmacist.Core/Generation/Resolvers/PublicStaticEventNamespaceResolver.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.Core/Generation/RoslynGeneratorExtensions.cs b/src/Pharmacist.Core/Generation/RoslynGeneratorExtensions.cs index 908838f..4867672 100644 --- a/src/Pharmacist.Core/Generation/RoslynGeneratorExtensions.cs +++ b/src/Pharmacist.Core/Generation/RoslynGeneratorExtensions.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -39,23 +39,22 @@ public static TypeSyntax GenerateTupleType(this IEnumerable<(IType Type, string public static TypeArgumentListSyntax GenerateObservableTypeArguments(this IMethod method) { - TypeArgumentListSyntax argumentList; - - // If we have no parameters, use the Unit type, if only one use the type directly, otherwise use a value tuple. - if (method.Parameters.Count == 0) - { - argumentList = TypeArgumentList(SingletonSeparatedList(IdentifierName(RoslynHelpers.ObservableUnitName))); - } - else if (method.Parameters.Count == 1) - { - argumentList = TypeArgumentList(SingletonSeparatedList(IdentifierName(method.Parameters[0].Type.GenerateFullGenericName()))); - } - else + return method.Parameters.Count switch { - argumentList = TypeArgumentList(SingletonSeparatedList(TupleType(SeparatedList(method.Parameters.Select(x => TupleElement(IdentifierName(x.Type.GenerateFullGenericName())).WithIdentifier(Identifier(x.Name))))))); - } - - return argumentList; + // If we have no parameters, use the Unit type, if only one use the type directly, otherwise use a value tuple. + 0 => TypeArgumentList( + SingletonSeparatedList(IdentifierName(RoslynHelpers.ObservableUnitName))), + 1 => TypeArgumentList( + SingletonSeparatedList( + IdentifierName(method.Parameters[0].Type.GenerateFullGenericName()))), + _ => TypeArgumentList( + SingletonSeparatedList( + TupleType( + SeparatedList( + method.Parameters.Select( + x => TupleElement(IdentifierName(x.Type.GenerateFullGenericName())) + .WithIdentifier(Identifier(x.Name))))))) + }; } public static TypeSyntax GenerateObservableType(this TypeArgumentListSyntax argumentList) @@ -72,36 +71,21 @@ public static PropertyDeclarationSyntax WithObsoleteAttribute(this PropertyDecla { var attribute = GenerateObsoleteAttributeList(eventDetails); - if (attribute == null) - { - return syntax; - } - - return syntax.WithAttributeLists(SingletonList(attribute)); + return attribute == null ? syntax : syntax.WithAttributeLists(SingletonList(attribute)); } public static ClassDeclarationSyntax WithObsoleteAttribute(this ClassDeclarationSyntax syntax, IEntity eventDetails) { var attribute = GenerateObsoleteAttributeList(eventDetails); - if (attribute == null) - { - return syntax; - } - - return syntax.WithAttributeLists(SingletonList(attribute)); + return attribute == null ? syntax : syntax.WithAttributeLists(SingletonList(attribute)); } public static MethodDeclarationSyntax WithObsoleteAttribute(this MethodDeclarationSyntax syntax, IEntity eventDetails) { var attribute = GenerateObsoleteAttributeList(eventDetails); - if (attribute == null) - { - return syntax; - } - - return syntax.WithAttributeLists(SingletonList(attribute)); + return attribute == null ? syntax : syntax.WithAttributeLists(SingletonList(attribute)); } public static ParameterListSyntax GenerateMethodParameters(this IMethod method) @@ -133,11 +117,21 @@ public static ParameterListSyntax GenerateMethodParameters(this IMethod method) return null; } - var message = obsoleteAttribute.FixedArguments.FirstOrDefault().Value.ToString(); - var isError = bool.Parse(obsoleteAttribute.FixedArguments.ElementAtOrDefault(1).Value?.ToString() ?? bool.FalseString) ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression; - var attribute = Attribute( - IdentifierName("global::System.ObsoleteAttribute"), - AttributeArgumentList(SeparatedList(new[] { AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(message))), AttributeArgument(LiteralExpression(isError)) }))); + var message = obsoleteAttribute.FixedArguments.FirstOrDefault().Value?.ToString(); + + AttributeSyntax attribute; + if (message is null || string.IsNullOrWhiteSpace(message)) + { + attribute = Attribute( + IdentifierName("global::System.ObsoleteAttribute")); + } + else + { + var isError = bool.Parse(obsoleteAttribute.FixedArguments.ElementAtOrDefault(1).Value?.ToString() ?? bool.FalseString) ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression; + attribute = Attribute( + IdentifierName("global::System.ObsoleteAttribute"), + AttributeArgumentList(SeparatedList(new[] { AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(message))), AttributeArgument(LiteralExpression(isError)) }))); + } return AttributeList(SingletonSeparatedList(attribute)); } diff --git a/src/Pharmacist.Core/Generation/RoslynHelpers.cs b/src/Pharmacist.Core/Generation/RoslynHelpers.cs index abce225..b39b86f 100644 --- a/src/Pharmacist.Core/Generation/RoslynHelpers.cs +++ b/src/Pharmacist.Core/Generation/RoslynHelpers.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -6,11 +6,6 @@ using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; -using NuGet.Frameworks; - -using Pharmacist.Core.Generation.Compilation; -using Pharmacist.Core.Groups; - namespace Pharmacist.Core.Generation { /// diff --git a/src/Pharmacist.Core/Generation/TypeDefinitionNameComparer.cs b/src/Pharmacist.Core/Generation/TypeDefinitionNameComparer.cs index 0b94d21..8f20bdd 100644 --- a/src/Pharmacist.Core/Generation/TypeDefinitionNameComparer.cs +++ b/src/Pharmacist.Core/Generation/TypeDefinitionNameComparer.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -14,7 +14,7 @@ namespace Pharmacist.Core.Generation /// internal class TypeDefinitionNameComparer : IEqualityComparer, IComparer { - public static TypeDefinitionNameComparer Default { get; } = new TypeDefinitionNameComparer(); + public static TypeDefinitionNameComparer Default { get; } = new(); /// public bool Equals(ITypeDefinition? x, ITypeDefinition? y) @@ -31,22 +31,12 @@ public int GetHashCode(ITypeDefinition obj) /// public int Compare(ITypeDefinition? x, ITypeDefinition? y) { - if (x == null && y == null) + return x switch { - return 0; - } - - if (x == null) - { - return -1; - } - - if (y == null) - { - return 1; - } - - return string.CompareOrdinal(x.GenerateFullGenericName(), y.GenerateFullGenericName()); + null when y == null => 0, + null => -1, + _ => y == null ? 1 : string.CompareOrdinal(x.GenerateFullGenericName(), y.GenerateFullGenericName()) + }; } } } diff --git a/src/Pharmacist.Core/Generation/TypeNameComparer.cs b/src/Pharmacist.Core/Generation/TypeNameComparer.cs index dff8c67..35f3293 100644 --- a/src/Pharmacist.Core/Generation/TypeNameComparer.cs +++ b/src/Pharmacist.Core/Generation/TypeNameComparer.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -11,7 +11,7 @@ namespace Pharmacist.Core.Generation { internal class TypeNameComparer : IEqualityComparer, IComparer { - public static TypeNameComparer Default { get; } = new TypeNameComparer(); + public static TypeNameComparer Default { get; } = new(); /// public bool Equals(IType? x, IType? y) @@ -28,22 +28,12 @@ public int GetHashCode(IType obj) /// public int Compare(IType? x, IType? y) { - if (x == null && y == null) + return x switch { - return 0; - } - - if (x == null) - { - return -1; - } - - if (y == null) - { - return 1; - } - - return string.CompareOrdinal(x.GenerateFullGenericName(), y.GenerateFullGenericName()); + null when y == null => 0, + null => -1, + _ => y == null ? 1 : string.CompareOrdinal(x.GenerateFullGenericName(), y.GenerateFullGenericName()) + }; } } } diff --git a/src/Pharmacist.Core/Generation/TypesMetadata.cs b/src/Pharmacist.Core/Generation/TypesMetadata.cs index 78e2080..06b2523 100644 --- a/src/Pharmacist.Core/Generation/TypesMetadata.cs +++ b/src/Pharmacist.Core/Generation/TypesMetadata.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.Core/Generation/XmlSyntaxFactory.cs b/src/Pharmacist.Core/Generation/XmlSyntaxFactory.cs index 62aa957..03e360f 100644 --- a/src/Pharmacist.Core/Generation/XmlSyntaxFactory.cs +++ b/src/Pharmacist.Core/Generation/XmlSyntaxFactory.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -84,9 +84,9 @@ public static SyntaxTriviaList GenerateSummarySeeAlsoComment(string summaryText, .Append("/// ").AppendLine(text) .AppendLine("/// "); - foreach (var parameter in parameters) + foreach (var (paramName, paramText) in parameters) { - sb.Append("/// ").Append(parameter.ParamText).AppendLine(""); + sb.Append("/// ").Append(paramText).AppendLine(""); } return SyntaxFactory.ParseLeadingTrivia(sb.ToString()); @@ -135,9 +135,9 @@ public static SyntaxTriviaList GenerateSummaryComment(string summaryText, IEnume .Append("/// ").AppendLine(summaryText) .AppendLine("/// "); - foreach (var parameter in parameters) + foreach (var (paramName, paramText) in parameters) { - sb.Append("/// ").Append(parameter.ParamText).AppendLine(""); + sb.Append("/// ").Append(paramText).AppendLine(""); } return SyntaxFactory.ParseLeadingTrivia(sb.ToString()); @@ -157,9 +157,9 @@ public static SyntaxTriviaList GenerateSummaryComment(string summaryText, IEnume .Append("/// ").AppendLine(summaryText) .AppendLine("/// "); - foreach (var parameter in parameters) + foreach (var (paramName, paramText) in parameters) { - sb.Append("/// ").Append(parameter.ParamText).AppendLine(""); + sb.Append("/// ").Append(paramText).AppendLine(""); } sb.Append("/// ").Append(returnValueText).AppendLine(""); diff --git a/src/Pharmacist.Core/Groups/FilesGroup.cs b/src/Pharmacist.Core/Groups/FilesGroup.cs index a4b9ec4..6632cff 100644 --- a/src/Pharmacist.Core/Groups/FilesGroup.cs +++ b/src/Pharmacist.Core/Groups/FilesGroup.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -6,6 +6,7 @@ using System; using System.Collections.Generic; using System.IO; +using System.Linq; namespace Pharmacist.Core.Groups { @@ -14,7 +15,7 @@ namespace Pharmacist.Core.Groups /// public class FilesGroup { - private readonly DirectoryNode _rootNode = new DirectoryNode(string.Empty); + private readonly DirectoryNode _rootNode = new(string.Empty); /// /// Gets for a file name, the nearest matching full name in the shallowest of the hierarchy. @@ -83,60 +84,29 @@ public void AddFiles(IEnumerable files) var splitDirectory = directoryPath?.Split(new[] { Path.PathSeparator, Path.AltDirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries) ?? Array.Empty(); - var directoryNode = _rootNode; + var directoryNode = splitDirectory.Aggregate(_rootNode, (current, currentPath) => current.AddChildNode(currentPath)); - foreach (var currentPath in splitDirectory) - { - directoryNode = directoryNode.AddChildNode(currentPath); - } - - directoryNode?.AddFile(file); + directoryNode.AddFile(file); } } private class DirectoryNode : IEqualityComparer, IComparable { - private readonly Dictionary _childNodesDict = new Dictionary(); - private readonly List _childNodes = new List(); - private readonly List _files = new List(); - private readonly Dictionary _filesDict = new Dictionary(); - - public DirectoryNode(DirectoryNode? parent, string name) - { - Name = name; - Parent = parent; - } + private readonly Dictionary _childNodesDict = new(); + private readonly List _childNodes = new(); + private readonly List _files = new(); + private readonly Dictionary _filesDict = new(); public DirectoryNode(string name) - : this(null, name) - { - } - - public string Name { get; } - - public string FullPath { - get - { - if (Parent == null || string.IsNullOrWhiteSpace(Parent.FullPath)) - { - return Name; - } - - return Parent.FullPath + Path.DirectorySeparatorChar + Name; - } + Name = name; } - public DirectoryNode? Parent { get; } - public IEnumerable Files => _files; public IEnumerable ChildNodes => _childNodes; - public bool TryGetChildNode(string path, out DirectoryNode? outValue) - { - return _childNodesDict.TryGetValue(path, out outValue); - } + private string Name { get; } public bool TryGetFile(string name, out string? outValue) { @@ -152,38 +122,50 @@ public bool TryGetFile(string name, out string? outValue) public DirectoryNode AddChildNode(string name) { - if (!_childNodesDict.TryGetValue(name, out var node)) + if (_childNodesDict.TryGetValue(name, out var node)) { - node = new DirectoryNode(this, name); - _childNodesDict.Add(name, node); - _childNodes.Add(node); + return node; } + node = new DirectoryNode(name); + _childNodesDict.Add(name, node); + _childNodes.Add(node); + return node; } - public FileNode AddFile(string fullPath) + public void AddFile(string fullPath) { var name = Path.GetFileName(fullPath); - if (!_filesDict.TryGetValue(name, out var node)) + if (_filesDict.TryGetValue(name, out var node)) { - node = new FileNode(name, fullPath); - _filesDict.Add(name, node); - var index = _files.BinarySearch(node); - if (index < 0) - { - _files.Insert(~index, node); - } + return; } - return node; + node = new FileNode(fullPath); + _filesDict.Add(name, node); + var index = _files.BinarySearch(node); + if (index < 0) + { + _files.Insert(~index, node); + } } /// - public bool Equals(DirectoryNode x, DirectoryNode y) + public bool Equals(DirectoryNode? x, DirectoryNode? y) { - return StringComparer.InvariantCultureIgnoreCase.Equals(x?.Name, y?.Name); + if (x == null && y == null) + { + return true; + } + + if (x == null || y == null) + { + return false; + } + + return ReferenceEquals(x, y) || StringComparer.InvariantCultureIgnoreCase.Equals(x.Name, y.Name); } /// @@ -193,38 +175,40 @@ public int GetHashCode(DirectoryNode obj) } /// - public int CompareTo(DirectoryNode other) + public int CompareTo(DirectoryNode? other) { if (ReferenceEquals(this, other)) { return 0; } - if (ReferenceEquals(null, other)) - { - return 1; - } - - return StringComparer.InvariantCultureIgnoreCase.Compare(this, other); + return ReferenceEquals(null, other) ? 1 : StringComparer.InvariantCultureIgnoreCase.Compare(this, other); } } private class FileNode : IEqualityComparer, IComparable { - public FileNode(string fileName, string fullPath) + public FileNode(string fullPath) { FullPath = fullPath; - FileName = fileName; } public string FullPath { get; } - public string FileName { get; } - /// - public bool Equals(FileNode x, FileNode y) + public bool Equals(FileNode? x, FileNode? y) { - return StringComparer.InvariantCultureIgnoreCase.Equals(x?.FullPath, y?.FullPath); + if (x == null && y == null) + { + return true; + } + + if (x == null || y == null) + { + return false; + } + + return ReferenceEquals(x, y) || StringComparer.InvariantCultureIgnoreCase.Equals(x.FullPath, y.FullPath); } /// @@ -234,7 +218,7 @@ public int GetHashCode(FileNode obj) } /// - public int CompareTo(FileNode other) + public int CompareTo(FileNode? other) { return StringComparer.InvariantCultureIgnoreCase.Compare(FullPath, other?.FullPath); } diff --git a/src/Pharmacist.Core/Groups/InputAssembliesGroup.cs b/src/Pharmacist.Core/Groups/InputAssembliesGroup.cs index 2999ccc..ca53f8e 100644 --- a/src/Pharmacist.Core/Groups/InputAssembliesGroup.cs +++ b/src/Pharmacist.Core/Groups/InputAssembliesGroup.cs @@ -1,8 +1,10 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. +using System; + namespace Pharmacist.Core.Groups { /// @@ -13,11 +15,59 @@ public class InputAssembliesGroup /// /// Gets a folder group which should contain the inclusions. /// - public FilesGroup IncludeGroup { get; internal set; } = new FilesGroup(); + public FilesGroup IncludeGroup { get; internal set; } = new(); /// /// Gets a folder group with folders for including for support files only. /// - public FilesGroup SupportGroup { get; internal set; } = new FilesGroup(); + public FilesGroup SupportGroup { get; internal set; } = new(); + + /// + /// Combines two groups together. + /// + /// The first group. + /// The second group. + /// The combined groups. + public static InputAssembliesGroup Combine(InputAssembliesGroup firstGroup, InputAssembliesGroup secondGroup) + { + if (firstGroup == null) + { + throw new ArgumentNullException(nameof(firstGroup)); + } + + if (secondGroup == null) + { + throw new ArgumentNullException(nameof(secondGroup)); + } + + var newGroup = new InputAssembliesGroup(); + + newGroup.IncludeGroup.AddFiles(firstGroup.IncludeGroup.GetAllFileNames()); + newGroup.IncludeGroup.AddFiles(secondGroup.IncludeGroup.GetAllFileNames()); + + newGroup.SupportGroup.AddFiles(firstGroup.SupportGroup.GetAllFileNames()); + newGroup.SupportGroup.AddFiles(secondGroup.SupportGroup.GetAllFileNames()); + + return newGroup; + } + + /// + /// Combines two groups together. + /// + /// The second group. + /// The combined groups. + public InputAssembliesGroup Combine(InputAssembliesGroup secondGroup) + { + if (secondGroup == null) + { + throw new ArgumentNullException(nameof(secondGroup)); + } + + IncludeGroup.AddFiles(secondGroup.IncludeGroup.GetAllFileNames()); + + SupportGroup.AddFiles(secondGroup.SupportGroup.GetAllFileNames()); + + return this; + } } } diff --git a/src/Pharmacist.Core/NuGet/NuGetFrameworkFolderHelper.cs b/src/Pharmacist.Core/NuGet/NuGetFrameworkFolderHelper.cs index bc4ac1a..6aed284 100644 --- a/src/Pharmacist.Core/NuGet/NuGetFrameworkFolderHelper.cs +++ b/src/Pharmacist.Core/NuGet/NuGetFrameworkFolderHelper.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -25,28 +25,15 @@ internal static class NuGetFrameworkFolderHelper /// A list of additional paths. public static IEnumerable GetNuGetFrameworkFolders(this NuGetFramework framework) { - IEnumerable folders; - switch (framework.Framework.ToLowerInvariant()) + IEnumerable folders = framework.Framework.ToLowerInvariant() switch { - case "monoandroid": - folders = HandleAndroid(framework); - break; - case "xamarin.ios": - folders = HandleiOS(); - break; - case "xamarin.tvos": - folders = HandleTVOS(); - break; - case "xamarin.watchos": - folders = HandleWatchOS(); - break; - case "xamarin.mac": - folders = HandleMac(); - break; - default: - folders = Array.Empty(); - break; - } + "monoandroid" => HandleAndroid(framework), + "xamarin.ios" => HandleiOS(), + "xamarin.tvos" => HandleTVOS(), + "xamarin.watchos" => HandleWatchOS(), + "xamarin.mac" => HandleMac(), + _ => Array.Empty() + }; return FileSystemHelpers.GetSubdirectoriesWithMatch(folders, AssemblyHelpers.AssemblyFileExtensionsSet); } @@ -73,7 +60,6 @@ private static IEnumerable HandleiOS() return new[] { Path.Combine(referenceAssembliesLocation, "Xamarin.iOS") }; } - [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1300:Element should begin with upper-case letter", Justification = "iOS special naming scheme.")] private static IEnumerable HandleMac() { var referenceAssembliesLocation = GetReferenceLocation("/Library/Frameworks/Xamarin.Mac.framework/Versions/Current/lib/mono/"); diff --git a/src/Pharmacist.Core/NuGet/NuGetFrameworkHelper.cs b/src/Pharmacist.Core/NuGet/NuGetFrameworkHelper.cs index 699bb85..a4e8e93 100644 --- a/src/Pharmacist.Core/NuGet/NuGetFrameworkHelper.cs +++ b/src/Pharmacist.Core/NuGet/NuGetFrameworkHelper.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -28,7 +28,10 @@ static NuGetFrameworkHelper() _nugetFrameworks = new Dictionary>(StringComparer.InvariantCultureIgnoreCase); foreach (var property in typeof(FrameworkConstants.CommonFrameworks).GetProperties(BindingFlags.NonPublic | BindingFlags.Static)) { - _nugetFrameworks[property.Name] = new[] { (NuGetFramework)property.GetValue(null) }; + if (property.GetValue(null) is NuGetFramework framework) + { + _nugetFrameworks[property.Name] = new[] { framework }; + } } // Some special cases for .net standard/.net app core since they require the '.' character in the numbers. @@ -51,6 +54,7 @@ static NuGetFrameworkHelper() _nugetFrameworks["NetCoreApp2.2"] = new[] { new NuGetFramework(".NETCoreApp", new Version(2, 1, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; _nugetFrameworks["NetCoreApp3.0"] = new[] { new NuGetFramework(".NETCoreApp", new Version(3, 0, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; _nugetFrameworks["NetCoreApp3.1"] = new[] { new NuGetFramework(".NETCoreApp", new Version(3, 1, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; + _nugetFrameworks["net5.0"] = new[] { FrameworkConstants.CommonFrameworks.Net50, FrameworkConstants.CommonFrameworks.NetStandard20 }; _nugetFrameworks["MonoAndroid50"] = new[] { new NuGetFramework("MonoAndroid", new Version(5, 0, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; _nugetFrameworks["MonoAndroid51"] = new[] { new NuGetFramework("MonoAndroid", new Version(5, 1, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; _nugetFrameworks["MonoAndroid60"] = new[] { new NuGetFramework("MonoAndroid", new Version(6, 0, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; @@ -59,7 +63,9 @@ static NuGetFrameworkHelper() _nugetFrameworks["MonoAndroid80"] = new[] { new NuGetFramework("MonoAndroid", new Version(8, 0, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; _nugetFrameworks["MonoAndroid81"] = new[] { new NuGetFramework("MonoAndroid", new Version(8, 1, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; _nugetFrameworks["MonoAndroid90"] = new[] { new NuGetFramework("MonoAndroid", new Version(9, 0, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; - _nugetFrameworks["MonoTouch10"] = new[] { new NuGetFramework("MonoAndroid", new Version(1, 0, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; + _nugetFrameworks["MonoAndroid10.0"] = new[] { new NuGetFramework("MonoAndroid", new Version(10, 0, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; + _nugetFrameworks["MonoAndroid11.0"] = new[] { new NuGetFramework("MonoAndroid", new Version(11, 0, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; + _nugetFrameworks["MonoTouch10"] = new[] { new NuGetFramework("MonoTouch", new Version(1, 0, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; _nugetFrameworks["Xamarin.iOS10"] = new[] { new NuGetFramework("Xamarin.iOS", new Version(1, 0, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; _nugetFrameworks["Xamarin.Mac20"] = new[] { new NuGetFramework("Xamarin.Mac", new Version(2, 0, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; _nugetFrameworks["Xamarin.TVOS10"] = new[] { new NuGetFramework("Xamarin.TVOS", new Version(1, 0, 0, 0)), FrameworkConstants.CommonFrameworks.NetStandard20 }; @@ -103,9 +109,20 @@ static NuGetFrameworkHelper() /// The framework. public static IReadOnlyList ToFrameworks(this string frameworkName) { + if (frameworkName is null) + { + throw new ArgumentNullException(nameof(frameworkName)); + } + + if (frameworkName.StartsWith("uap", StringComparison.CurrentCultureIgnoreCase)) + { + var versionText = frameworkName.Substring(3); + return new[] { new NuGetFramework("UAP", new Version(versionText)), FrameworkConstants.CommonFrameworks.NetStandard20 }; + } + _nugetFrameworks.TryGetValue(frameworkName, out var framework); - return framework; + return framework ?? Array.Empty(); } /// @@ -127,7 +144,7 @@ public static IEnumerable GetSupportLibraries(this NuGetFramewo if (framework.Framework.StartsWith(".NETCoreApp", StringComparison.OrdinalIgnoreCase)) { - return new[] { new PackageIdentity("Microsoft.NETCore.App", new NuGetVersion(framework.Version)) }; + return new[] { new PackageIdentity("Microsoft.NETCore.App.Ref", new NuGetVersion(framework.Version)) }; } if (framework.Framework.StartsWith("Tizen", StringComparison.OrdinalIgnoreCase)) diff --git a/src/Pharmacist.Core/NuGet/NuGetLogger.cs b/src/Pharmacist.Core/NuGet/NuGetLogger.cs index 121753b..93f64cf 100644 --- a/src/Pharmacist.Core/NuGet/NuGetLogger.cs +++ b/src/Pharmacist.Core/NuGet/NuGetLogger.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -36,6 +36,12 @@ public void Log(LogLevel level, string data) case LogLevel.Debug: this.Log().Debug(data); break; + case LogLevel.Verbose: + this.Log().Info(data); + break; + case LogLevel.Minimal: + this.Log().Info(data); + break; default: this.Log().Info(data); break; diff --git a/src/Pharmacist.Core/NuGet/NuGetPackageHelper.cs b/src/Pharmacist.Core/NuGet/NuGetPackageHelper.cs index 39800d5..c6f664e 100644 --- a/src/Pharmacist.Core/NuGet/NuGetPackageHelper.cs +++ b/src/Pharmacist.Core/NuGet/NuGetPackageHelper.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -16,7 +16,6 @@ using NuGet.LibraryModel; using NuGet.Packaging; using NuGet.Packaging.Core; -using NuGet.Protocol; using NuGet.Protocol.Core.Types; using NuGet.Versioning; @@ -42,9 +41,9 @@ public static class NuGetPackageHelper // Bunch of NuGet based objects we can cache and only create once. private static readonly string _globalPackagesPath; - private static readonly NuGetLogger _logger = new NuGetLogger(); + private static readonly NuGetLogger _logger = new(); private static readonly SourceCacheContext _sourceCacheContext = NullSourceCacheContext.Instance; - private static readonly PackageDownloadContext _downloadContext = new PackageDownloadContext(_sourceCacheContext); + private static readonly PackageDownloadContext _downloadContext = new(_sourceCacheContext); private static readonly IFrameworkNameProvider _frameworkNameProvider = DefaultFrameworkNameProvider.Instance; static NuGetPackageHelper() @@ -185,7 +184,7 @@ public static async Task GetBestMatch(LibraryRange identity, Fi /// A cancellation token. /// The directory where the NuGet packages are unzipped to. Also the files contained within the requested package only. private static async Task DownloadPackageFilesAndFolder( - IReadOnlyCollection packageIdentities, + IEnumerable packageIdentities, IReadOnlyCollection frameworks, DownloadResource downloadResource, bool getDependencies = true, @@ -202,7 +201,7 @@ private static async Task DownloadPackageFilesAndFolder( } private static async Task> GetPackagesToCopy( - IReadOnlyCollection startingPackages, + IEnumerable startingPackages, DownloadResource downloadResource, IReadOnlyCollection frameworks, bool getDependencies, @@ -227,15 +226,7 @@ private static async Task DownloadPackageFilesAndFolder( var count = stack.TryPopRange(processingItems); var currentItems = processingItems.Take(count).Where( - item => - { - if (packagesToCopy.TryGetValue(item.PackageIdentity, out var existingValue) && item.PackageIdentity.Version <= existingValue.PackageIdentity.Version) - { - return false; - } - - return true; - }).ToList(); + item => !packagesToCopy.TryGetValue(item.PackageIdentity, out var existingValue) || item.PackageIdentity.Version > existingValue.PackageIdentity.Version).ToList(); // Download the resource into the global packages path. We get a result which allows us to copy or do other operations based on the files. (DownloadResourceResult DownloadResourceResult, PackageIdentity PackageIdentity, bool IncludeFilesInOutput)[] results = await Task.WhenAll( @@ -256,7 +247,7 @@ private static async Task DownloadPackageFilesAndFolder( } private static InputAssembliesGroup CopyPackageFiles( - IReadOnlyCollection<(DownloadResourceResult DownloadResourceResult, PackageIdentity PackageIdentity, bool IncludeFilesInOutput)> packagesToProcess, + IEnumerable<(DownloadResourceResult DownloadResourceResult, PackageIdentity PackageIdentity, bool IncludeFilesInOutput)> packagesToProcess, IReadOnlyCollection frameworks, IReadOnlyCollection packageFolders, string packageDirectory, @@ -288,15 +279,15 @@ private static InputAssembliesGroup CopyPackageFiles( _logger, token))); - foreach (var folder in folders) + foreach (var (_, files) in folders) { if (includeFilesInOutput) { - inputAssembliesGroup.IncludeGroup.AddFiles(folder.files); + inputAssembliesGroup.IncludeGroup.AddFiles(files); } else { - inputAssembliesGroup.SupportGroup.AddFiles(folder.files); + inputAssembliesGroup.SupportGroup.AddFiles(files); } } } @@ -329,15 +320,12 @@ private static IEnumerable GetDependencyPackages(DownloadResour .FirstOrDefault(); // If no packages match our framework just return an empty array. - if (highestFramework == null) - { - return Array.Empty(); - } - - return highestFramework.Packages.Select(package => new PackageIdentity(package.Id, package.VersionRange.MinVersion)); + return highestFramework == null ? + Array.Empty() : + highestFramework.Packages.Select(package => new PackageIdentity(package.Id, package.VersionRange.MinVersion)); } - private static IEnumerable<(string Folder, IEnumerable Files)> GetFileGroups(this PackageReaderBase reader, IReadOnlyCollection folders, IReadOnlyCollection frameworksToInclude) + private static IEnumerable<(string Folder, IEnumerable Files)> GetFileGroups(this IPackageCoreReader reader, IReadOnlyCollection folders, IReadOnlyCollection frameworksToInclude) { var groups = new Dictionary>>(new NuGetFrameworkFullComparer()); foreach (var folder in folders) @@ -415,23 +403,25 @@ private static NuGetFramework GetFrameworkFromPath(this IPackageCoreReader reade { var nuGetFramework = NuGetFramework.AnyFramework; var strArray = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries); - if ((strArray.Length == 3 || strArray.Length > 3) && allowSubFolders) + if ((strArray.Length != 3 && strArray.Length <= 3) || !allowSubFolders) { - var folderName = strArray[1]; - NuGetFramework folder; - try - { - folder = NuGetFramework.ParseFolder(folderName, _frameworkNameProvider); - } - catch (ArgumentException ex) - { - throw new PackagingException(string.Format(CultureInfo.CurrentCulture, "There is a invalid project {0}, {1}", path, reader.GetIdentity()), ex); - } + return nuGetFramework; + } - if (folder.IsSpecificFramework) - { - nuGetFramework = folder; - } + var folderName = strArray[1]; + NuGetFramework folder; + try + { + folder = NuGetFramework.ParseFolder(folderName, _frameworkNameProvider); + } + catch (ArgumentException ex) + { + throw new PackagingException(string.Format(CultureInfo.CurrentCulture, "There is a invalid project {0}, {1}", path, reader.GetIdentity()), ex); + } + + if (folder.IsSpecificFramework) + { + nuGetFramework = folder; } return nuGetFramework; diff --git a/src/Pharmacist.Core/ObservablesForEventGenerator.cs b/src/Pharmacist.Core/ObservablesForEventGenerator.cs index f7a16b1..374bff0 100644 --- a/src/Pharmacist.Core/ObservablesForEventGenerator.cs +++ b/src/Pharmacist.Core/ObservablesForEventGenerator.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -6,7 +6,6 @@ using System; using System.Collections.Generic; using System.Diagnostics; -using System.Diagnostics.CodeAnalysis; using System.Globalization; using System.IO; using System.Linq; @@ -22,7 +21,6 @@ using Pharmacist.Core.Extractors; using Pharmacist.Core.Extractors.PlatformExtractors; -using Pharmacist.Core.Generation; using Pharmacist.Core.Generation.Compilation; using Pharmacist.Core.Generation.Resolvers; using Pharmacist.Core.Groups; @@ -54,47 +52,75 @@ public static class ObservablesForEventGenerator /// The prefix to add to the start of the output file. /// The suffix to add to the end of output file names. /// A directory path to where reference assemblies can be located. - /// The platforms to generate for. + /// The target platform to generate for. + /// If to generate for WPF. + /// If to generate for WinForms. /// Directory for the packages, if null a random path in the temp folder will be used. + /// If the header should be included. /// A task to monitor the progress. - [SuppressMessage("Design", "CA2000: Dispose Object", Justification = "Analyzer can't handle loop based using statements.")] - public static async Task ExtractEventsFromPlatforms(string outputPath, string prefix, string suffix, string defaultReferenceAssemblyLocation, IEnumerable platforms, string? packageOutputFolder = null) + public static async Task ExtractEventsFromPlatforms(string outputPath, string prefix, string suffix, string defaultReferenceAssemblyLocation, string targetFramework, bool isWpf, bool isWinForms, string? packageOutputFolder = null, bool includeHeader = true) { - var platformExtractors = new IPlatformExtractor[] - { - new Android(), - new iOS(), - new Mac(), - new TVOS(), - new UWP(), - new Winforms(packageOutputFolder), - new WPF(packageOutputFolder), - }.ToDictionary(x => x.Platform); - - if (platforms == null) + var platformExtractors = new List + { + new Android(), + new iOS(), + new Mac(), + new TVOS(), + new UWP(), + new WatchOs() + }; + + if (isWinForms) + { + platformExtractors.Add(new Winforms(packageOutputFolder)); + } + + if (isWpf) + { + platformExtractors.Add(new WPF(packageOutputFolder)); + } + + LogHost.Default.Info("Starting to process " + targetFramework); + + var frameworks = targetFramework.ToFrameworks().ToArray(); + + if (frameworks.Length == 0) + { + LogHost.Default.Error(CultureInfo.InvariantCulture, "Could not find any valid frameworks for {0}", targetFramework); + return; + } + + var framework = frameworks[0]; + + var extractors = platformExtractors.Where(x => x.CanExtract(frameworks)).ToList(); + + if (extractors.Count == 0) { - throw new ArgumentNullException(nameof(platforms)); + throw new InvalidOperationException( + "Could not find valid extractors for framework " + framework); } - foreach (var platform in platforms) + var inputGroup = new InputAssembliesGroup(); + foreach (var extractor in extractors) { - LogHost.Default.Info(CultureInfo.InvariantCulture, "Processing platform {0}", platform); - var platformExtractor = platformExtractors[platform]; - await platformExtractor.Extract(defaultReferenceAssemblyLocation).ConfigureAwait(false); + await extractor.Extract(frameworks, defaultReferenceAssemblyLocation).ConfigureAwait(false); - if (platformExtractor.Input == null) + if (extractor.Input == null) { throw new Exception("Cannot find valid input from the specified Platform."); } - using (var streamWriter = new StreamWriter(Path.Combine(outputPath, prefix + platform.ToString().ToLowerInvariant() + suffix))) - { - await WriteHeader(streamWriter, platform).ConfigureAwait(false); - await ExtractEventsFromAssemblies(streamWriter, platformExtractor.Input, platformExtractor.Framework).ConfigureAwait(false); - } + inputGroup = inputGroup.Combine(extractor.Input); + } + + using var streamWriter = new StreamWriter(Path.Combine(outputPath, prefix + targetFramework.ToLowerInvariant() + suffix)); - LogHost.Default.Info(CultureInfo.InvariantCulture, "Finished platform {0}", platform); + if (includeHeader) + { + await WriteHeader(streamWriter, framework).ConfigureAwait(false); } + + await ExtractEventsFromAssemblies(streamWriter, inputGroup, framework).ConfigureAwait(false); } /// @@ -186,7 +212,7 @@ public static async Task WriteHeader(TextWriter writer) /// The writer where to output to. /// The target framework being generated. /// A task to monitor the progress. - public static async Task WriteHeader(TextWriter writer, string targetFramework) + public static async Task WriteHeader(TextWriter writer, NuGetFramework targetFramework) { if (writer == null) { @@ -281,26 +307,6 @@ public static async Task WriteHeader(TextWriter writer, IEnumerable file await writer.FlushAsync().ConfigureAwait(false); } - /// - /// Writes the header for a output. - /// - /// The writer where to output to. - /// The packages we are writing for.. - /// A task to monitor the progress. - public static async Task WriteHeader(TextWriter writer, AutoPlatform autoPlatform) - { - if (writer == null) - { - throw new ArgumentNullException(nameof(writer)); - } - - await WriteHeader(writer).ConfigureAwait(false); - - await writer.WriteLineAsync($"// Platform included: {autoPlatform}").ConfigureAwait(false); - - await writer.FlushAsync().ConfigureAwait(false); - } - /// /// Extracts the events and delegates from the specified platform. /// @@ -315,23 +321,23 @@ public static async Task ExtractEventsFromAssemblies(TextWriter writer, InputAss throw new ArgumentNullException(nameof(writer)); } - using (var compilation = new EventBuilderCompiler(input, framework)) - { - var compilationOutputSyntax = CompilationUnit() - .WithMembers(List(_resolvers.SelectMany(x => x.Create(compilation)))) - .WithUsings(List(new[] - { + var compilation = new EventBuilderCompiler(input, framework); + var compilationOutputSyntax = CompilationUnit() + .WithMembers(List(_resolvers.SelectMany(x => x.Create(compilation)))) + .WithUsings(List(new[] + { UsingDirective(IdentifierName("global::System")), UsingDirective(IdentifierName("global::System.Reactive")), UsingDirective(IdentifierName("global::System.Reactive.Linq")), UsingDirective(IdentifierName("global::System.Reactive.Subjects")), UsingDirective(IdentifierName("global::Pharmacist.Common")) - })); + })); - await writer.WriteAsync(Environment.NewLine).ConfigureAwait(false); - await writer.WriteAsync(compilationOutputSyntax.NormalizeWhitespace(elasticTrivia: true).ToString()).ConfigureAwait(false); - await writer.FlushAsync().ConfigureAwait(false); - } + await writer.WriteAsync(Environment.NewLine).ConfigureAwait(false); + await writer.WriteAsync(compilationOutputSyntax.NormalizeWhitespace(elasticTrivia: true).ToString()).ConfigureAwait(false); + await writer.FlushAsync().ConfigureAwait(false); + + compilation.Dispose(); } /// diff --git a/src/Pharmacist.Core/Pharmacist.Core.csproj b/src/Pharmacist.Core/Pharmacist.Core.csproj index 9293410..8c24d25 100644 --- a/src/Pharmacist.Core/Pharmacist.Core.csproj +++ b/src/Pharmacist.Core/Pharmacist.Core.csproj @@ -1,7 +1,6 @@ - + - netstandard2.0 - $(TargetFrameworks);net461 + netstandard2.0;net5.0;net461 latest false enable @@ -12,19 +11,14 @@ - - - - + + + - - - - - + + - diff --git a/src/Pharmacist.Core/PlatformHelper.cs b/src/Pharmacist.Core/PlatformHelper.cs index de422b8..71c9b71 100644 --- a/src/Pharmacist.Core/PlatformHelper.cs +++ b/src/Pharmacist.Core/PlatformHelper.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -13,7 +13,7 @@ namespace Pharmacist.Core /// public static class PlatformHelper { - private static readonly Lazy _IsRunningOnMono = new Lazy(() => !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); + private static readonly Lazy _IsRunningOnMono = new(() => !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)); /// /// Determines whether the platform is running on mono. diff --git a/src/Pharmacist.Core/Properties/AssemblyInfo.cs b/src/Pharmacist.Core/Properties/AssemblyInfo.cs index 6cccb5a..a648ebe 100644 --- a/src/Pharmacist.Core/Properties/AssemblyInfo.cs +++ b/src/Pharmacist.Core/Properties/AssemblyInfo.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.Core/ReferenceLocators/ReferenceLocationNotFoundException.cs b/src/Pharmacist.Core/ReferenceLocators/ReferenceLocationNotFoundException.cs index f9cae55..bed8893 100644 --- a/src/Pharmacist.Core/ReferenceLocators/ReferenceLocationNotFoundException.cs +++ b/src/Pharmacist.Core/ReferenceLocators/ReferenceLocationNotFoundException.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.Core/ReferenceLocators/ReferenceLocator.cs b/src/Pharmacist.Core/ReferenceLocators/ReferenceLocator.cs index 417dddc..6ace5cd 100644 --- a/src/Pharmacist.Core/ReferenceLocators/ReferenceLocator.cs +++ b/src/Pharmacist.Core/ReferenceLocators/ReferenceLocator.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -26,9 +26,9 @@ namespace Pharmacist.Core.ReferenceLocators /// public static class ReferenceLocator { - private static readonly PackageIdentity VSWherePackageIdentity = new PackageIdentity("VSWhere", new NuGetVersion("2.6.7")); + private static readonly PackageIdentity VSWherePackageIdentity = new("VSWhere", new NuGetVersion("2.6.7")); - private static readonly ConcurrentDictionary _windowsInstallationDirectory = new ConcurrentDictionary(); + private static readonly ConcurrentDictionary _windowsInstallationDirectory = new(); /// /// Gets the reference location. @@ -42,14 +42,16 @@ public static string GetReferenceLocation(bool includePreRelease = true) return "/Library/Frameworks"; } - if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { - var visualStudioInstallation = GetWindowsInstallationDirectory(includePreRelease); - - return Path.Combine(visualStudioInstallation, "Common7", "IDE", "ReferenceAssemblies", "Microsoft", "Framework"); + throw new ReferenceLocationNotFoundException( + "Visual Studio reference location not supported on this platform: " + + RuntimeInformation.OSDescription); } - throw new ReferenceLocationNotFoundException("Visual Studio reference location not supported on this platform: " + RuntimeInformation.OSDescription); + var visualStudioInstallation = GetWindowsInstallationDirectory(includePreRelease); + + return Path.Combine(visualStudioInstallation, "Common7", "IDE", "ReferenceAssemblies", "Microsoft", "Framework"); } private static string GetWindowsInstallationDirectory(bool includePreRelease) @@ -81,21 +83,24 @@ private static string GetWindowsInstallationDirectory(bool includePreRelease) parameters.Append(" -prerelease"); } - using (var process = new Process()) - { - process.StartInfo.FileName = fileName; - process.StartInfo.Arguments = parameters.ToString(); - process.StartInfo.UseShellExecute = false; - process.StartInfo.RedirectStandardOutput = true; + using var process = new Process + { + StartInfo = + { + FileName = fileName, + Arguments = parameters.ToString(), + UseShellExecute = false, + RedirectStandardOutput = true + } + }; - process.Start(); + process.Start(); - // To avoid deadlocks, always read the output stream first and then wait. - var output = process.StandardOutput.ReadToEnd().Replace(Environment.NewLine, string.Empty); - process.WaitForExit(); + // To avoid deadlocks, always read the output stream first and then wait. + var output = (await process.StandardOutput.ReadToEndAsync().ConfigureAwait(false)).Replace(Environment.NewLine, string.Empty); + process.WaitForExit(); - return output; - } + return output; }).ConfigureAwait(false).GetAwaiter().GetResult(); }); } diff --git a/src/Pharmacist.Core/TemplateManager.cs b/src/Pharmacist.Core/TemplateManager.cs index 2699486..9c84e4f 100644 --- a/src/Pharmacist.Core/TemplateManager.cs +++ b/src/Pharmacist.Core/TemplateManager.cs @@ -1,8 +1,9 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. +using System; using System.IO; using System.Reflection; using System.Text; @@ -21,10 +22,15 @@ public static async Task GetTemplateAsync(string templateName) { var assembly = Assembly.GetExecutingAssembly(); - using (var streamReader = new StreamReader(assembly.GetManifestResourceStream(templateName), Encoding.UTF8)) + var manifestStream = assembly.GetManifestResourceStream(templateName); + + if (manifestStream is null) { - return await streamReader.ReadToEndAsync().ConfigureAwait(false); + throw new InvalidOperationException("Could not find the valid template"); } + + using var streamReader = new StreamReader(manifestStream, Encoding.UTF8); + return await streamReader.ReadToEndAsync().ConfigureAwait(false); } } } diff --git a/src/Pharmacist.Core/Utilities/AssemblyHelpers.cs b/src/Pharmacist.Core/Utilities/AssemblyHelpers.cs index 4758098..855c9f7 100644 --- a/src/Pharmacist.Core/Utilities/AssemblyHelpers.cs +++ b/src/Pharmacist.Core/Utilities/AssemblyHelpers.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -39,12 +39,7 @@ internal static class AssemblyHelpers var file = Path.Combine(basePath, name + ".winmd"); - if (!File.Exists(file)) - { - return null; - } - - return file; + return !File.Exists(file) ? null : file; } internal static string? FindWindowsMetadataFile(string name, Version version) @@ -71,37 +66,27 @@ internal static class AssemblyHelpers var file = Path.Combine(basePath, name + ".winmd"); - if (!File.Exists(file)) - { - return FindWindowsMetadataInSystemDirectory(name); - } - - return file; + return !File.Exists(file) ? FindWindowsMetadataInSystemDirectory(name) : file; } private static string? FindWindowsMetadataInSystemDirectory(string name) { var file = Path.Combine(Environment.SystemDirectory, "WinMetadata", name + ".winmd"); - if (File.Exists(file)) - { - return file; - } - - return null; + return File.Exists(file) ? file : null; } private static string FindClosestVersionDirectory(string basePath, Version version) { string? path = null; - foreach (var folder in new DirectoryInfo(basePath) + foreach (var (versionFolder, name) in new DirectoryInfo(basePath) .EnumerateDirectories() .Select(d => ConvertToVersion(d.Name)) - .Where(v => v.Item1 != null) - .OrderByDescending(v => v.Item1)) + .Where(v => v.Version != null) + .OrderBy(v => v.Version)) { - if (path == null || folder.Item1 >= version) + if (path == null || versionFolder >= version) { - path = folder.Item2; + path = name; } } diff --git a/src/Pharmacist.Core/Utilities/FileSystemHelpers.cs b/src/Pharmacist.Core/Utilities/FileSystemHelpers.cs index 4ae47be..d28683d 100644 --- a/src/Pharmacist.Core/Utilities/FileSystemHelpers.cs +++ b/src/Pharmacist.Core/Utilities/FileSystemHelpers.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.Core/Utilities/QueueExtensions.cs b/src/Pharmacist.Core/Utilities/QueueExtensions.cs index 73919e6..6caa413 100644 --- a/src/Pharmacist.Core/Utilities/QueueExtensions.cs +++ b/src/Pharmacist.Core/Utilities/QueueExtensions.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.Core/Utilities/StackExtensions.cs b/src/Pharmacist.Core/Utilities/StackExtensions.cs index d8de6a5..2f8a1f1 100644 --- a/src/Pharmacist.Core/Utilities/StackExtensions.cs +++ b/src/Pharmacist.Core/Utilities/StackExtensions.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.IntegrationTest/InstanceClass.cs b/src/Pharmacist.IntegrationTest/InstanceClass.cs index aaebaec..2f55275 100644 --- a/src/Pharmacist.IntegrationTest/InstanceClass.cs +++ b/src/Pharmacist.IntegrationTest/InstanceClass.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.IntegrationTest/Pharmacist.IntegrationTest.csproj b/src/Pharmacist.IntegrationTest/Pharmacist.IntegrationTest.csproj index 223ac31..f9e1948 100644 --- a/src/Pharmacist.IntegrationTest/Pharmacist.IntegrationTest.csproj +++ b/src/Pharmacist.IntegrationTest/Pharmacist.IntegrationTest.csproj @@ -1,7 +1,7 @@  - netstandard2.0 + netstandard2.0;net5.0 false diff --git a/src/Pharmacist.MsBuild.NuGet/MsBuildLogger.cs b/src/Pharmacist.MsBuild.NuGet/MsBuildLogger.cs index ccabd0e..d6baa50 100644 --- a/src/Pharmacist.MsBuild.NuGet/MsBuildLogger.cs +++ b/src/Pharmacist.MsBuild.NuGet/MsBuildLogger.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -53,6 +53,9 @@ public void Write(string message, LogLevel logLevel) case LogLevel.Fatal: _log.LogError(message); break; + default: + _log.LogMessage(message); + break; } } @@ -79,6 +82,9 @@ public void Write(Exception exception, string message, LogLevel logLevel) case LogLevel.Fatal: _log.LogErrorFromException(exception); break; + default: + _log.LogMessage(exception?.ToString()); + break; } } @@ -103,6 +109,9 @@ public void Write(string message, Type type, LogLevel logLevel) case LogLevel.Fatal: _log.LogError(message); break; + default: + _log.LogMessage(message); + break; } } @@ -129,6 +138,9 @@ public void Write(Exception exception, string message, Type type, LogLevel logLe case LogLevel.Fatal: _log.LogErrorFromException(exception); break; + default: + _log.LogMessage(exception?.ToString()); + break; } } } diff --git a/src/Pharmacist.MsBuild.NuGet/Pharmacist.MsBuild.NuGet.csproj b/src/Pharmacist.MsBuild.NuGet/Pharmacist.MsBuild.NuGet.csproj index 3a6bdf2..898547c 100644 --- a/src/Pharmacist.MsBuild.NuGet/Pharmacist.MsBuild.NuGet.csproj +++ b/src/Pharmacist.MsBuild.NuGet/Pharmacist.MsBuild.NuGet.csproj @@ -1,4 +1,4 @@ - + netstandard2.0 @@ -16,7 +16,8 @@ - + + @@ -24,6 +25,8 @@ + + diff --git a/src/Pharmacist.MsBuild.NuGet/PharmacistNuGetTask.cs b/src/Pharmacist.MsBuild.NuGet/PharmacistNuGetTask.cs index 19af22e..1b3f2df 100644 --- a/src/Pharmacist.MsBuild.NuGet/PharmacistNuGetTask.cs +++ b/src/Pharmacist.MsBuild.NuGet/PharmacistNuGetTask.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -12,7 +12,7 @@ using System.Text.RegularExpressions; using Microsoft.Build.Framework; using Microsoft.Build.Utilities; -using Newtonsoft.Json; + using NuGet.Frameworks; using NuGet.LibraryModel; using NuGet.Packaging.Core; @@ -31,14 +31,14 @@ namespace Pharmacist.MsBuild.NuGet [SuppressMessage("Design", "CA1031: Catch specific exceptions", Justification = "Final logging location for exceptions.")] public class PharmacistNuGetTask : Task, IEnableLogger { - private static readonly Regex _versionRegex = new Regex(@"(\d+\.)?(\d+\.)?(\d+\.)?(\*|\d+)", RegexOptions.Compiled | RegexOptions.CultureInvariant); - private static readonly Regex _packageRegex = new Regex("^(.*)/(.*)$", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.IgnoreCase); - private static readonly Dictionary _guidToFramework = new Dictionary() + private static readonly Regex _versionRegex = new(@"(\d+\.)?(\d+\.)?(\d+\.)?(\*|\d+)", RegexOptions.Compiled | RegexOptions.CultureInvariant); + private static readonly Regex _packageRegex = new("^(.*)/(.*)$", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.IgnoreCase); + private static readonly Dictionary _guidToFramework = new() { [new Guid("EFBA0AD7-5A72-4C68-AF49-83D382785DCF")] = "MonoAndroid", [new Guid("6BC8ED88-2882-458C-8E55-DFD12B67127B")] = "Xamarin.iOS", [new Guid("A5A43C5B-DE2A-4C0C-9213-0A381AF9435A")] = "uap", - [new Guid("A3F8F2AB-B479-4A4A-A458-A89E7DC349F1")] = "Xamarin.Mac", + [new Guid("A3F8F2AB-B479-4A4A-A458-A89E7DC349F1")] = "Xamarin.Mac" }; private static readonly ISet ExclusionPackageReferenceSet = new HashSet(StringComparer.InvariantCultureIgnoreCase) @@ -128,7 +128,7 @@ public override bool Execute() return true; } - private static void WritePackages(List packageIdentities, string lockFileName) + private static void WritePackages(IEnumerable packageIdentities, string lockFileName) { using var streamWriter = new StreamWriter(lockFileName, false, Encoding.UTF8); foreach (var packageIdentity in packageIdentities) @@ -200,11 +200,13 @@ private IReadOnlyCollection GetTargetFrameworks() var versionText = string.IsNullOrWhiteSpace(TargetFrameworkVersion) ? TargetFrameworkVersion : TargetPlatformVersion; foreach (var projectGuid in projectGuids) { - if (_guidToFramework.TryGetValue(projectGuid, out var targetFrameworkValue)) + if (!_guidToFramework.TryGetValue(projectGuid, out var targetFrameworkValue)) { - var versionMatch = new Version(_versionRegex.Match(versionText).Value); - nugetFrameworks.Add(new NuGetFramework(targetFrameworkValue, versionMatch)); + continue; } + + var versionMatch = new Version(_versionRegex.Match(versionText).Value); + nugetFrameworks.Add(new NuGetFramework(targetFrameworkValue, versionMatch)); } return nugetFrameworks; diff --git a/src/Pharmacist.MsBuild.NuGet/targets/Pharmacist.MSBuild.targets b/src/Pharmacist.MsBuild.NuGet/targets/Pharmacist.MSBuild.targets index d7b96f7..d6c29fa 100644 --- a/src/Pharmacist.MsBuild.NuGet/targets/Pharmacist.MSBuild.targets +++ b/src/Pharmacist.MsBuild.NuGet/targets/Pharmacist.MSBuild.targets @@ -37,7 +37,7 @@ $(MSBuildProjectDirectory)\obj\$(Configuration)\ $(MSBuildThisFileDirectory)..\..\build\netstandard2.0\Pharmacist.MSBuild.dll - $(MSBuildThisFileDirectory)..\..\build\net461\Pharmacist.MSBuild.dll + $(MSBuildThisFileDirectory)..\..\build\net472\Pharmacist.MSBuild.dll $(IntermediateOutputPath)\Pharmacist.NuGet.g.cs $(IntermediateOutputPath)\Pharmacist.NuGet.g.cs.lock diff --git a/src/Pharmacist.MsBuild.TargetFramework/MsBuildLogger.cs b/src/Pharmacist.MsBuild.TargetFramework/MsBuildLogger.cs index 5eff739..6273bd7 100644 --- a/src/Pharmacist.MsBuild.TargetFramework/MsBuildLogger.cs +++ b/src/Pharmacist.MsBuild.TargetFramework/MsBuildLogger.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. diff --git a/src/Pharmacist.MsBuild.TargetFramework/Pharmacist.MsBuild.TargetFramework.csproj b/src/Pharmacist.MsBuild.TargetFramework/Pharmacist.MsBuild.TargetFramework.csproj index 5c3959d..44bb48a 100644 --- a/src/Pharmacist.MsBuild.TargetFramework/Pharmacist.MsBuild.TargetFramework.csproj +++ b/src/Pharmacist.MsBuild.TargetFramework/Pharmacist.MsBuild.TargetFramework.csproj @@ -1,7 +1,7 @@ - + - netstandard2.0 + netstandard2.0;net5.0 $(TargetFrameworks);net461 Pharmacist.MSBuild.TargetFramework @@ -15,6 +15,7 @@ + @@ -22,6 +23,8 @@ + + diff --git a/src/Pharmacist.MsBuild.TargetFramework/PharmacistTargetFrameworkTask.cs b/src/Pharmacist.MsBuild.TargetFramework/PharmacistTargetFrameworkTask.cs index 40534c9..75c13b3 100644 --- a/src/Pharmacist.MsBuild.TargetFramework/PharmacistTargetFrameworkTask.cs +++ b/src/Pharmacist.MsBuild.TargetFramework/PharmacistTargetFrameworkTask.cs @@ -1,4 +1,4 @@ -// Copyright (c) 2019 .NET Foundation and Contributors. All rights reserved. +// Copyright (c) 2019-2020 .NET Foundation and Contributors. All rights reserved. // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. @@ -52,11 +52,12 @@ public override bool Execute() using (var writer = new StreamWriter(Path.Combine(OutputFile))) { - ObservablesForEventGenerator.WriteHeader(writer, TargetFramework).ConfigureAwait(false).GetAwaiter().GetResult(); + var frameworks = TargetFramework.ToFrameworks(); + ObservablesForEventGenerator.WriteHeader(writer, frameworks[0]).ConfigureAwait(false).GetAwaiter().GetResult(); try { - ObservablesForEventGenerator.ExtractEventsFromTargetFramework(writer, TargetFramework.ToFrameworks()).GetAwaiter().GetResult(); + ObservablesForEventGenerator.ExtractEventsFromTargetFramework(writer, frameworks).GetAwaiter().GetResult(); } catch (Exception ex) { diff --git a/src/Pharmacist.MsBuild.TargetFramework/targets/Pharmacist.MSBuild.TargetFramework.targets b/src/Pharmacist.MsBuild.TargetFramework/targets/Pharmacist.MSBuild.TargetFramework.targets index 303b20d..e381943 100644 --- a/src/Pharmacist.MsBuild.TargetFramework/targets/Pharmacist.MSBuild.TargetFramework.targets +++ b/src/Pharmacist.MsBuild.TargetFramework/targets/Pharmacist.MSBuild.TargetFramework.targets @@ -10,7 +10,7 @@ $(MSBuildProjectDirectory)\obj\$(Configuration)\ $(MSBuildThisFileDirectory)..\..\build\netstandard2.0\Pharmacist.MSBuild.TargetFramework.dll - $(MSBuildThisFileDirectory)..\..\build\net461\Pharmacist.MSBuild.TargetFramework.dll + $(MSBuildThisFileDirectory)..\..\build\net472\Pharmacist.MSBuild.TargetFramework.dll diff --git a/src/Pharmacist.Tests/API/ApiApprovalTests.EventBuilderProject.net472.approved.txt b/src/Pharmacist.Tests/API/ApiApprovalTests.EventBuilderProject.net472.approved.txt deleted file mode 100644 index 1c871fe..0000000 --- a/src/Pharmacist.Tests/API/ApiApprovalTests.EventBuilderProject.net472.approved.txt +++ /dev/null @@ -1,129 +0,0 @@ -[assembly: System.Runtime.CompilerServices.InternalsVisibleToAttribute("Pharmacist.Benchmarks")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleToAttribute("Pharmacist.Tests")] -[assembly: System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.6.1", FrameworkDisplayName=".NET Framework 4.6.1")] -namespace Pharmacist.Core -{ - public enum AutoPlatform - { - Android = 0, - iOS = 1, - Mac = 2, - WPF = 3, - UWP = 4, - Winforms = 5, - TVOS = 6, - } - public class static ObservablesForEventGenerator - { - public static System.Threading.Tasks.Task ExtractEventsFromAssemblies(System.IO.TextWriter writer, System.Collections.Generic.IEnumerable assemblyPaths, System.Collections.Generic.IEnumerable searchDirectories) { } - public static System.Threading.Tasks.Task ExtractEventsFromNuGetPackages(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection packages, System.Collections.Generic.IReadOnlyCollection frameworks, string packageOutputFolder = null) { } - public static System.Threading.Tasks.Task ExtractEventsFromNuGetPackages(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection packages, System.Collections.Generic.IReadOnlyCollection frameworks, string packageOutputFolder = null) { } - public static System.Threading.Tasks.Task ExtractEventsFromPlatforms(string outputPath, string prefix, string suffix, string defaultReferenceAssemblyLocation, System.Collections.Generic.IEnumerable platforms, string packageOutputFolder = null) { } - public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer) { } - public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection libraryRanges) { } - public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, System.Collections.Generic.IEnumerable fileNames) { } - public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, Pharmacist.Core.AutoPlatform autoPlatform) { } - } - public class static PlatformHelper - { - public static bool IsRunningOnMono() { } - } -} -namespace Pharmacist.Core.Extractors -{ - public interface IExtractor - { - System.Collections.Generic.IEnumerable Assemblies { get; } - System.Collections.Generic.IEnumerable SearchDirectories { get; } - } - public class NuGetExtractor : Pharmacist.Core.Extractors.IExtractor - { - public NuGetExtractor() { } - public System.Collections.Generic.IEnumerable Assemblies { get; } - public System.Collections.Generic.IEnumerable SearchDirectories { get; } - public System.Threading.Tasks.Task Extract(System.Collections.Generic.IReadOnlyCollection targetFrameworks, System.Collections.Generic.IReadOnlyCollection packages, string packageOutputDirectory) { } - public System.Threading.Tasks.Task Extract(System.Collections.Generic.IReadOnlyCollection targetFrameworks, System.Collections.Generic.IReadOnlyCollection packages, string packageOutputDirectory) { } - } -} -namespace Pharmacist.Core.Extractors.PlatformExtractors -{ - public class Android : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform - { - public Android() { } - public override Pharmacist.Core.AutoPlatform Platform { get; } - public override System.Threading.Tasks.Task Extract(string referenceAssembliesLocation) { } - } - public abstract class BasePlatform : Pharmacist.Core.Extractors.IExtractor, Pharmacist.Core.Extractors.PlatformExtractors.IPlatformExtractor - { - protected BasePlatform() { } - public System.Collections.Generic.IEnumerable Assemblies { get; set; } - public abstract Pharmacist.Core.AutoPlatform Platform { get; } - public System.Collections.Generic.IEnumerable SearchDirectories { get; set; } - public abstract System.Threading.Tasks.Task Extract(string referenceAssembliesLocation); - } - public interface IPlatformExtractor : Pharmacist.Core.Extractors.IExtractor - { - Pharmacist.Core.AutoPlatform Platform { get; } - System.Threading.Tasks.Task Extract(string referenceAssembliesLocation); - } - public class Mac : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform - { - public Mac() { } - public override Pharmacist.Core.AutoPlatform Platform { get; } - public override System.Threading.Tasks.Task Extract(string referenceAssembliesLocation) { } - } - public class TVOS : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform - { - public TVOS() { } - public override Pharmacist.Core.AutoPlatform Platform { get; } - public override System.Threading.Tasks.Task Extract(string referenceAssembliesLocation) { } - } - public class UWP : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform - { - public UWP() { } - public override Pharmacist.Core.AutoPlatform Platform { get; } - public override System.Threading.Tasks.Task Extract(string referenceAssembliesLocation) { } - } - public class iOS : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform - { - public iOS() { } - public override Pharmacist.Core.AutoPlatform Platform { get; } - public override System.Threading.Tasks.Task Extract(string referenceAssembliesLocation) { } - } -} -namespace Pharmacist.Core.NuGet -{ - public class static NuGetFrameworkHelper - { - public static System.Collections.Generic.IEnumerable GetSupportLibraries(this NuGet.Frameworks.NuGetFramework framework) { } - public static System.Collections.Generic.IReadOnlyList ToFrameworks(this string frameworkName) { } - } - public class static NuGetPackageHelper - { - public const string DefaultNuGetSource = "https://api.nuget.org/v3/index.json"; - public static System.Collections.Generic.List> Providers { get; } - [return: System.Runtime.CompilerServices.TupleElementNamesAttribute(new string[] { - "folder", - "files"})] - public static System.Threading.Tasks.Task>>> DownloadPackageFilesAndFolder(System.Collections.Generic.IReadOnlyCollection libraryIdentities, System.Collections.Generic.IReadOnlyCollection frameworks = null, NuGet.Configuration.PackageSource nugetSource = null, bool getDependencies = True, System.Collections.Generic.IReadOnlyCollection packageFolders = null, string packageOutputDirectory = null, System.Threading.CancellationToken token = null) { } - [return: System.Runtime.CompilerServices.TupleElementNamesAttribute(new string[] { - "folder", - "files"})] - public static System.Threading.Tasks.Task>>> DownloadPackageFilesAndFolder(System.Collections.Generic.IReadOnlyCollection packageIdentities, System.Collections.Generic.IReadOnlyCollection frameworks = null, NuGet.Configuration.PackageSource nugetSource = null, bool getDependencies = True, System.Collections.Generic.IReadOnlyCollection packageFolders = null, string packageOutputDirectory = null, System.Threading.CancellationToken token = null) { } - public static System.Threading.Tasks.Task GetBestMatch(NuGet.LibraryModel.LibraryRange identity, NuGet.Protocol.Core.Types.FindPackageByIdResource findPackageResource, System.Threading.CancellationToken token) { } - } -} -namespace Pharmacist.Core.ReferenceLocators -{ - public class ReferenceLocationNotFoundException : System.Exception - { - public ReferenceLocationNotFoundException(string message) { } - public ReferenceLocationNotFoundException(string message, System.Exception innerException) { } - public ReferenceLocationNotFoundException() { } - protected ReferenceLocationNotFoundException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public class static ReferenceLocator - { - public static System.Threading.Tasks.Task GetReferenceLocation(bool includePreRelease = True) { } - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/API/ApiApprovalTests.EventBuilderProject.netcoreapp2.2.approved.txt b/src/Pharmacist.Tests/API/ApiApprovalTests.EventBuilderProject.net5.0.approved.txt similarity index 53% rename from src/Pharmacist.Tests/API/ApiApprovalTests.EventBuilderProject.netcoreapp2.2.approved.txt rename to src/Pharmacist.Tests/API/ApiApprovalTests.EventBuilderProject.net5.0.approved.txt index 2a866b0..70cff48 100644 --- a/src/Pharmacist.Tests/API/ApiApprovalTests.EventBuilderProject.netcoreapp2.2.approved.txt +++ b/src/Pharmacist.Tests/API/ApiApprovalTests.EventBuilderProject.net5.0.approved.txt @@ -1,47 +1,19 @@ -[assembly: System.Runtime.CompilerServices.InternalsVisibleToAttribute("Pharmacist.Benchmarks")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleToAttribute("Pharmacist.Tests")] -[assembly: System.Runtime.Versioning.TargetFrameworkAttribute(".NETStandard,Version=v2.0", FrameworkDisplayName="")] -namespace Pharmacist.Core -{ - public enum AutoPlatform - { - Android = 0, - iOS = 1, - Mac = 2, - WPF = 3, - UWP = 4, - Winforms = 5, - TVOS = 6, - } - public class static ObservablesForEventGenerator - { - public static System.Threading.Tasks.Task ExtractEventsFromAssemblies(System.IO.TextWriter writer, System.Collections.Generic.IEnumerable assemblies, System.Collections.Generic.IEnumerable searchDirectories, string targetFramework) { } - public static System.Threading.Tasks.Task ExtractEventsFromAssemblies(System.IO.TextWriter writer, Pharmacist.Core.Groups.InputAssembliesGroup input, NuGet.Frameworks.NuGetFramework framework) { } - public static System.Threading.Tasks.Task ExtractEventsFromNuGetPackages(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection packages, System.Collections.Generic.IReadOnlyCollection frameworks, string packageOutputFolder = null) { } - public static System.Threading.Tasks.Task ExtractEventsFromNuGetPackages(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection packages, System.Collections.Generic.IReadOnlyCollection frameworks, string packageOutputFolder = null) { } - public static System.Threading.Tasks.Task ExtractEventsFromPlatforms(string outputPath, string prefix, string suffix, string defaultReferenceAssemblyLocation, System.Collections.Generic.IEnumerable platforms, string packageOutputFolder = null) { } - public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer) { } - public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection libraryRanges) { } - public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, System.Collections.Generic.IEnumerable fileNames) { } - public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, Pharmacist.Core.AutoPlatform autoPlatform) { } - } - public class static PlatformHelper - { - public static bool IsRunningOnMono() { } - } -} +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/reactiveui/Pharmacist")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Pharmacist.Benchmarks")] +[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Pharmacist.Tests")] +[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v5.0", FrameworkDisplayName="")] namespace Pharmacist.Core.Extractors { public interface IExtractor { - Pharmacist.Core.Groups.InputAssembliesGroup Input { get; } + Pharmacist.Core.Groups.InputAssembliesGroup? Input { get; } } public class NuGetExtractor : Pharmacist.Core.Extractors.IExtractor { public NuGetExtractor() { } - public Pharmacist.Core.Groups.InputAssembliesGroup Input { get; } - public System.Threading.Tasks.Task Extract(System.Collections.Generic.IReadOnlyCollection targetFrameworks, System.Collections.Generic.IReadOnlyCollection packages, string packageOutputDirectory) { } - public System.Threading.Tasks.Task Extract(System.Collections.Generic.IReadOnlyCollection targetFrameworks, System.Collections.Generic.IReadOnlyCollection packages, string packageOutputDirectory) { } + public Pharmacist.Core.Groups.InputAssembliesGroup? Input { get; set; } + public System.Threading.Tasks.Task Extract(System.Collections.Generic.IReadOnlyCollection targetFrameworks, System.Collections.Generic.IReadOnlyCollection packages, string? packageOutputDirectory) { } + public System.Threading.Tasks.Task Extract(System.Collections.Generic.IReadOnlyCollection targetFrameworks, System.Collections.Generic.IReadOnlyCollection packages, string? packageOutputDirectory) { } } } namespace Pharmacist.Core.Extractors.PlatformExtractors @@ -49,51 +21,50 @@ namespace Pharmacist.Core.Extractors.PlatformExtractors public class Android : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform { public Android() { } - public override NuGet.Frameworks.NuGetFramework Framework { get; } - public override Pharmacist.Core.AutoPlatform Platform { get; } - public override System.Threading.Tasks.Task Extract(string referenceAssembliesLocation) { } + public override bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks) { } + public override System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation) { } } public abstract class BasePlatform : Pharmacist.Core.Extractors.IExtractor, Pharmacist.Core.Extractors.PlatformExtractors.IPlatformExtractor { protected BasePlatform() { } - public abstract NuGet.Frameworks.NuGetFramework Framework { get; } - public Pharmacist.Core.Groups.InputAssembliesGroup Input { get; set; } - public abstract Pharmacist.Core.AutoPlatform Platform { get; } - public abstract System.Threading.Tasks.Task Extract(string referenceAssembliesLocation); + public Pharmacist.Core.Groups.InputAssembliesGroup Input { get; } + public abstract bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks); + public abstract System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation); } public interface IPlatformExtractor : Pharmacist.Core.Extractors.IExtractor { - NuGet.Frameworks.NuGetFramework Framework { get; } - Pharmacist.Core.AutoPlatform Platform { get; } - System.Threading.Tasks.Task Extract(string referenceAssembliesLocation); + bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks); + System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation); } public class Mac : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform { public Mac() { } - public override NuGet.Frameworks.NuGetFramework Framework { get; } - public override Pharmacist.Core.AutoPlatform Platform { get; } - public override System.Threading.Tasks.Task Extract(string referenceAssembliesLocation) { } + public override bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks) { } + public override System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation) { } } public class TVOS : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform { public TVOS() { } - public override NuGet.Frameworks.NuGetFramework Framework { get; } - public override Pharmacist.Core.AutoPlatform Platform { get; } - public override System.Threading.Tasks.Task Extract(string referenceAssembliesLocation) { } + public override bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks) { } + public override System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation) { } } public class UWP : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform { public UWP() { } - public override NuGet.Frameworks.NuGetFramework Framework { get; } - public override Pharmacist.Core.AutoPlatform Platform { get; } - public override System.Threading.Tasks.Task Extract(string referenceAssembliesLocation) { } + public override bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks) { } + public override System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation) { } + } + public class WatchOs : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform + { + public WatchOs() { } + public override bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks) { } + public override System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation) { } } public class iOS : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform { public iOS() { } - public override NuGet.Frameworks.NuGetFramework Framework { get; } - public override Pharmacist.Core.AutoPlatform Platform { get; } - public override System.Threading.Tasks.Task Extract(string referenceAssembliesLocation) { } + public override bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks) { } + public override System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation) { } } } namespace Pharmacist.Core.Groups @@ -103,42 +74,67 @@ namespace Pharmacist.Core.Groups public FilesGroup() { } public void AddFiles(System.Collections.Generic.IEnumerable files) { } public System.Collections.Generic.IEnumerable GetAllFileNames() { } - public string GetFullFilePath(string fileName) { } + public string? GetFullFilePath(string fileName) { } } public class InputAssembliesGroup { public InputAssembliesGroup() { } public Pharmacist.Core.Groups.FilesGroup IncludeGroup { get; } public Pharmacist.Core.Groups.FilesGroup SupportGroup { get; } + public Pharmacist.Core.Groups.InputAssembliesGroup Combine(Pharmacist.Core.Groups.InputAssembliesGroup secondGroup) { } + public static Pharmacist.Core.Groups.InputAssembliesGroup Combine(Pharmacist.Core.Groups.InputAssembliesGroup firstGroup, Pharmacist.Core.Groups.InputAssembliesGroup secondGroup) { } } } namespace Pharmacist.Core.NuGet { - public class static NuGetFrameworkHelper + public static class NuGetFrameworkHelper { public static System.Collections.Generic.IEnumerable GetSupportLibraries(this NuGet.Frameworks.NuGetFramework framework) { } public static System.Collections.Generic.IReadOnlyList ToFrameworks(this string frameworkName) { } } - public class static NuGetPackageHelper + public static class NuGetPackageHelper { public const string DefaultNuGetSource = "https://api.nuget.org/v3/index.json"; public static System.Collections.Generic.List> Providers { get; } - public static System.Threading.Tasks.Task DownloadPackageFilesAndFolder(System.Collections.Generic.IReadOnlyCollection libraryIdentities, System.Collections.Generic.IReadOnlyCollection frameworks = null, NuGet.Configuration.PackageSource nugetSource = null, bool getDependencies = True, System.Collections.Generic.IReadOnlyCollection packageFolders = null, string packageOutputDirectory = null, System.Threading.CancellationToken token = null) { } - public static System.Threading.Tasks.Task DownloadPackageFilesAndFolder(System.Collections.Generic.IReadOnlyCollection packageIdentities, System.Collections.Generic.IReadOnlyCollection frameworks = null, NuGet.Configuration.PackageSource nugetSource = null, bool getDependencies = True, System.Collections.Generic.IReadOnlyCollection packageFolders = null, string packageOutputDirectory = null, System.Threading.CancellationToken token = null) { } + public static System.Threading.Tasks.Task DownloadPackageFilesAndFolder(System.Collections.Generic.IReadOnlyCollection libraryIdentities, System.Collections.Generic.IReadOnlyCollection? frameworks = null, NuGet.Configuration.PackageSource? nugetSource = null, bool getDependencies = true, System.Collections.Generic.IReadOnlyCollection? packageFolders = null, string? packageOutputDirectory = null, System.Threading.CancellationToken token = default) { } + public static System.Threading.Tasks.Task DownloadPackageFilesAndFolder(System.Collections.Generic.IReadOnlyCollection packageIdentities, System.Collections.Generic.IReadOnlyCollection? frameworks = null, NuGet.Configuration.PackageSource? nugetSource = null, bool getDependencies = true, System.Collections.Generic.IReadOnlyCollection? packageFolders = null, string? packageOutputDirectory = null, System.Threading.CancellationToken token = default) { } + public static System.Threading.Tasks.Task GetBestMatch(NuGet.LibraryModel.LibraryRange identity, NuGet.Configuration.PackageSource? nugetSource = null, System.Threading.CancellationToken token = default) { } public static System.Threading.Tasks.Task GetBestMatch(NuGet.LibraryModel.LibraryRange identity, NuGet.Protocol.Core.Types.FindPackageByIdResource findPackageResource, System.Threading.CancellationToken token) { } } } +namespace Pharmacist.Core +{ + public static class ObservablesForEventGenerator + { + public static System.Threading.Tasks.Task ExtractEventsFromAssemblies(System.IO.TextWriter writer, Pharmacist.Core.Groups.InputAssembliesGroup input, NuGet.Frameworks.NuGetFramework framework) { } + public static System.Threading.Tasks.Task ExtractEventsFromAssemblies(System.IO.TextWriter writer, System.Collections.Generic.IEnumerable assemblies, System.Collections.Generic.IEnumerable searchDirectories, string targetFramework) { } + public static System.Threading.Tasks.Task ExtractEventsFromNuGetPackages(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection packages, System.Collections.Generic.IReadOnlyCollection frameworks, string? packageOutputFolder = null) { } + public static System.Threading.Tasks.Task ExtractEventsFromNuGetPackages(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection packages, System.Collections.Generic.IReadOnlyCollection frameworks, string? packageOutputFolder = null) { } + public static System.Threading.Tasks.Task ExtractEventsFromPlatforms(string outputPath, string prefix, string suffix, string defaultReferenceAssemblyLocation, string targetFramework, bool isWpf, bool isWinForms, string? packageOutputFolder = null, bool includeHeader = true) { } + public static System.Threading.Tasks.Task ExtractEventsFromTargetFramework(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyList frameworks) { } + public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer) { } + public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, NuGet.Frameworks.NuGetFramework targetFramework) { } + public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, System.Collections.Generic.IEnumerable fileNames) { } + public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection libraryRanges) { } + public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection packageIdentities) { } + } + public static class PlatformHelper + { + public static bool IsRunningOnMono() { } + } +} namespace Pharmacist.Core.ReferenceLocators { + [System.Serializable] public class ReferenceLocationNotFoundException : System.Exception { - public ReferenceLocationNotFoundException(string message) { } - public ReferenceLocationNotFoundException(string message, System.Exception innerException) { } public ReferenceLocationNotFoundException() { } + public ReferenceLocationNotFoundException(string message) { } protected ReferenceLocationNotFoundException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + public ReferenceLocationNotFoundException(string message, System.Exception innerException) { } } - public class static ReferenceLocator + public static class ReferenceLocator { - public static string GetReferenceLocation(bool includePreRelease = True) { } + public static string GetReferenceLocation(bool includePreRelease = true) { } } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/API/ApiApprovalTests.EventBuilderProject.netcoreapp3.1.approved.txt b/src/Pharmacist.Tests/API/ApiApprovalTests.EventBuilderProject.netcoreapp3.1.approved.txt index 4432956..a186672 100644 --- a/src/Pharmacist.Tests/API/ApiApprovalTests.EventBuilderProject.netcoreapp3.1.approved.txt +++ b/src/Pharmacist.Tests/API/ApiApprovalTests.EventBuilderProject.netcoreapp3.1.approved.txt @@ -1,38 +1,7 @@ +[assembly: System.Reflection.AssemblyMetadata("RepositoryUrl", "https://github.com/reactiveui/Pharmacist")] [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Pharmacist.Benchmarks")] [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Pharmacist.Tests")] [assembly: System.Runtime.Versioning.TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName="")] -namespace Pharmacist.Core -{ - public enum AutoPlatform - { - Android = 0, - iOS = 1, - Mac = 2, - WPF = 3, - UWP = 4, - Winforms = 5, - TVOS = 6, - } - public static class ObservablesForEventGenerator - { - public static System.Threading.Tasks.Task ExtractEventsFromAssemblies(System.IO.TextWriter writer, Pharmacist.Core.Groups.InputAssembliesGroup input, NuGet.Frameworks.NuGetFramework framework) { } - public static System.Threading.Tasks.Task ExtractEventsFromAssemblies(System.IO.TextWriter writer, System.Collections.Generic.IEnumerable assemblies, System.Collections.Generic.IEnumerable searchDirectories, string targetFramework) { } - public static System.Threading.Tasks.Task ExtractEventsFromNuGetPackages(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection packages, System.Collections.Generic.IReadOnlyCollection frameworks, string? packageOutputFolder = null) { } - public static System.Threading.Tasks.Task ExtractEventsFromNuGetPackages(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection packages, System.Collections.Generic.IReadOnlyCollection frameworks, string? packageOutputFolder = null) { } - public static System.Threading.Tasks.Task ExtractEventsFromPlatforms(string outputPath, string prefix, string suffix, string defaultReferenceAssemblyLocation, System.Collections.Generic.IEnumerable platforms, string? packageOutputFolder = null) { } - public static System.Threading.Tasks.Task ExtractEventsFromTargetFramework(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyList frameworks) { } - public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer) { } - public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, Pharmacist.Core.AutoPlatform autoPlatform) { } - public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, System.Collections.Generic.IEnumerable fileNames) { } - public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection libraryRanges) { } - public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection packageIdentities) { } - public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, string targetFramework) { } - } - public static class PlatformHelper - { - public static bool IsRunningOnMono() { } - } -} namespace Pharmacist.Core.Extractors { public interface IExtractor @@ -52,51 +21,50 @@ namespace Pharmacist.Core.Extractors.PlatformExtractors public class Android : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform { public Android() { } - public override NuGet.Frameworks.NuGetFramework Framework { get; } - public override Pharmacist.Core.AutoPlatform Platform { get; } - public override System.Threading.Tasks.Task Extract(string referenceAssembliesLocation) { } + public override bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks) { } + public override System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation) { } } public abstract class BasePlatform : Pharmacist.Core.Extractors.IExtractor, Pharmacist.Core.Extractors.PlatformExtractors.IPlatformExtractor { protected BasePlatform() { } - public abstract NuGet.Frameworks.NuGetFramework Framework { get; } public Pharmacist.Core.Groups.InputAssembliesGroup Input { get; } - public abstract Pharmacist.Core.AutoPlatform Platform { get; } - public abstract System.Threading.Tasks.Task Extract(string referenceAssembliesLocation); + public abstract bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks); + public abstract System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation); } public interface IPlatformExtractor : Pharmacist.Core.Extractors.IExtractor { - NuGet.Frameworks.NuGetFramework Framework { get; } - Pharmacist.Core.AutoPlatform Platform { get; } - System.Threading.Tasks.Task Extract(string referenceAssembliesLocation); + bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks); + System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation); } public class Mac : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform { public Mac() { } - public override NuGet.Frameworks.NuGetFramework Framework { get; } - public override Pharmacist.Core.AutoPlatform Platform { get; } - public override System.Threading.Tasks.Task Extract(string referenceAssembliesLocation) { } + public override bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks) { } + public override System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation) { } } public class TVOS : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform { public TVOS() { } - public override NuGet.Frameworks.NuGetFramework Framework { get; } - public override Pharmacist.Core.AutoPlatform Platform { get; } - public override System.Threading.Tasks.Task Extract(string referenceAssembliesLocation) { } + public override bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks) { } + public override System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation) { } } public class UWP : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform { public UWP() { } - public override NuGet.Frameworks.NuGetFramework Framework { get; } - public override Pharmacist.Core.AutoPlatform Platform { get; } - public override System.Threading.Tasks.Task Extract(string referenceAssembliesLocation) { } + public override bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks) { } + public override System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation) { } + } + public class WatchOs : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform + { + public WatchOs() { } + public override bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks) { } + public override System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation) { } } public class iOS : Pharmacist.Core.Extractors.PlatformExtractors.BasePlatform { public iOS() { } - public override NuGet.Frameworks.NuGetFramework Framework { get; } - public override Pharmacist.Core.AutoPlatform Platform { get; } - public override System.Threading.Tasks.Task Extract(string referenceAssembliesLocation) { } + public override bool CanExtract(NuGet.Frameworks.NuGetFramework[] frameworks) { } + public override System.Threading.Tasks.Task Extract(NuGet.Frameworks.NuGetFramework[] frameworks, string referenceAssembliesLocation) { } } } namespace Pharmacist.Core.Groups @@ -113,6 +81,8 @@ namespace Pharmacist.Core.Groups public InputAssembliesGroup() { } public Pharmacist.Core.Groups.FilesGroup IncludeGroup { get; } public Pharmacist.Core.Groups.FilesGroup SupportGroup { get; } + public Pharmacist.Core.Groups.InputAssembliesGroup Combine(Pharmacist.Core.Groups.InputAssembliesGroup secondGroup) { } + public static Pharmacist.Core.Groups.InputAssembliesGroup Combine(Pharmacist.Core.Groups.InputAssembliesGroup firstGroup, Pharmacist.Core.Groups.InputAssembliesGroup secondGroup) { } } } namespace Pharmacist.Core.NuGet @@ -132,6 +102,27 @@ namespace Pharmacist.Core.NuGet public static System.Threading.Tasks.Task GetBestMatch(NuGet.LibraryModel.LibraryRange identity, NuGet.Protocol.Core.Types.FindPackageByIdResource findPackageResource, System.Threading.CancellationToken token) { } } } +namespace Pharmacist.Core +{ + public static class ObservablesForEventGenerator + { + public static System.Threading.Tasks.Task ExtractEventsFromAssemblies(System.IO.TextWriter writer, Pharmacist.Core.Groups.InputAssembliesGroup input, NuGet.Frameworks.NuGetFramework framework) { } + public static System.Threading.Tasks.Task ExtractEventsFromAssemblies(System.IO.TextWriter writer, System.Collections.Generic.IEnumerable assemblies, System.Collections.Generic.IEnumerable searchDirectories, string targetFramework) { } + public static System.Threading.Tasks.Task ExtractEventsFromNuGetPackages(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection packages, System.Collections.Generic.IReadOnlyCollection frameworks, string? packageOutputFolder = null) { } + public static System.Threading.Tasks.Task ExtractEventsFromNuGetPackages(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection packages, System.Collections.Generic.IReadOnlyCollection frameworks, string? packageOutputFolder = null) { } + public static System.Threading.Tasks.Task ExtractEventsFromPlatforms(string outputPath, string prefix, string suffix, string defaultReferenceAssemblyLocation, string targetFramework, bool isWpf, bool isWinForms, string? packageOutputFolder = null, bool includeHeader = true) { } + public static System.Threading.Tasks.Task ExtractEventsFromTargetFramework(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyList frameworks) { } + public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer) { } + public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, NuGet.Frameworks.NuGetFramework targetFramework) { } + public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, System.Collections.Generic.IEnumerable fileNames) { } + public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection libraryRanges) { } + public static System.Threading.Tasks.Task WriteHeader(System.IO.TextWriter writer, System.Collections.Generic.IReadOnlyCollection packageIdentities) { } + } + public static class PlatformHelper + { + public static bool IsRunningOnMono() { } + } +} namespace Pharmacist.Core.ReferenceLocators { [System.Serializable] diff --git a/src/Pharmacist.Tests/API/ApiApprovalTests.cs b/src/Pharmacist.Tests/API/ApiApprovalTests.cs index b7b3c75..2159cb9 100644 --- a/src/Pharmacist.Tests/API/ApiApprovalTests.cs +++ b/src/Pharmacist.Tests/API/ApiApprovalTests.cs @@ -77,7 +77,8 @@ private static string Filter(string text) new[] { Environment.NewLine - }, StringSplitOptions.RemoveEmptyEntries) + }, + StringSplitOptions.RemoveEmptyEntries) .Where(l => !l.StartsWith("[assembly: AssemblyVersion(", StringComparison.InvariantCulture) && !l.StartsWith("[assembly: AssemblyFileVersion(", StringComparison.InvariantCulture) && diff --git a/src/Pharmacist.Tests/AssemblyIntegrationTests.cs b/src/Pharmacist.Tests/AssemblyIntegrationTests.cs index acbae6e..ad06e81 100644 --- a/src/Pharmacist.Tests/AssemblyIntegrationTests.cs +++ b/src/Pharmacist.Tests/AssemblyIntegrationTests.cs @@ -30,25 +30,21 @@ public class AssemblyIntegrationTests [Fact] public async Task IntegrationTestAssemblyTest() { - using (var memoryStream = new MemoryStream()) - { - var input = await NuGetPackageHelper.DownloadPackageFilesAndFolder(new[] { new PackageIdentity("NETStandard.Library", new NuGetVersion("2.0.0")) }).ConfigureAwait(false); + using var memoryStream = new MemoryStream(); + var input = await NuGetPackageHelper.DownloadPackageFilesAndFolder(new[] { new PackageIdentity("NETStandard.Library", new NuGetVersion("2.0.0")) }).ConfigureAwait(false); - using (var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8, 1024, true)) - { - await ObservablesForEventGenerator.ExtractEventsFromAssemblies(streamWriter, input, FrameworkConstants.CommonFrameworks.NetStandard20).ConfigureAwait(false); - } + using (var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8, 1024, true)) + { + await ObservablesForEventGenerator.ExtractEventsFromAssemblies(streamWriter, input, FrameworkConstants.CommonFrameworks.NetStandard20).ConfigureAwait(false); + } - memoryStream.Flush(); + memoryStream.Flush(); - memoryStream.Position = 0; - using (var sr = new StreamReader(memoryStream)) - { - var contents = sr.ReadToEnd(); + memoryStream.Position = 0; + using var sr = new StreamReader(memoryStream); + var contents = sr.ReadToEnd(); - contents.Should().NotBeEmpty(); - } - } + contents.Should().NotBeEmpty(); } } } diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.net461.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.net472.approved.txt similarity index 93% rename from src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.net461.approved.txt rename to src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.net472.approved.txt index 8427975..d31db4c 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.net461.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.net472.approved.txt @@ -1,3 +1,4 @@ + using global::System; using global::System.Reactive; using global::System.Reactive.Linq; @@ -59,9 +60,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } /// @@ -86,9 +85,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.AvaloniaPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -113,9 +110,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.AvaloniaPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InheritablePropertyChanged += x, x => _data.InheritablePropertyChanged -= x); + }, x => _data.InheritablePropertyChanged += x, x => _data.InheritablePropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -123,9 +118,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.AvaloniaPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -150,9 +143,7 @@ namespace Avalonia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Initialized += x, x => _data.Initialized -= x); + }, x => _data.Initialized += x, x => _data.Initialized -= x); } /// @@ -177,9 +168,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AttachedToLogicalTree += x, x => _data.AttachedToLogicalTree -= x); + }, x => _data.AttachedToLogicalTree += x, x => _data.AttachedToLogicalTree -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -187,9 +176,7 @@ namespace Avalonia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -197,9 +184,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DetachedFromLogicalTree += x, x => _data.DetachedFromLogicalTree -= x); + }, x => _data.DetachedFromLogicalTree += x, x => _data.DetachedFromLogicalTree -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -207,9 +192,7 @@ namespace Avalonia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Initialized += x, x => _data.Initialized -= x); + }, x => _data.Initialized += x, x => _data.Initialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -217,9 +200,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } /// @@ -244,9 +225,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AttachedToVisualTree += x, x => _data.AttachedToVisualTree -= x); + }, x => _data.AttachedToVisualTree += x, x => _data.AttachedToVisualTree -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -254,9 +233,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DetachedFromVisualTree += x, x => _data.DetachedFromVisualTree -= x); + }, x => _data.DetachedFromVisualTree += x, x => _data.DetachedFromVisualTree -= x); } } @@ -295,9 +272,7 @@ namespace Avalonia.Collections { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -305,9 +280,7 @@ namespace Avalonia.Collections { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } } @@ -414,9 +387,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -424,9 +395,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownClosing += x, x => _data.DropDownClosing -= x); + }, x => _data.DropDownClosing += x, x => _data.DropDownClosing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -434,9 +403,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -444,9 +411,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -454,9 +419,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.PopulatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Populated += x, x => _data.Populated -= x); + }, x => _data.Populated += x, x => _data.Populated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -464,9 +427,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.PopulatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Populating += x, x => _data.Populating -= x); + }, x => _data.Populating += x, x => _data.Populating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -474,9 +435,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -484,9 +443,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -511,9 +468,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -538,9 +493,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -548,9 +501,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -558,9 +509,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); } /// @@ -585,9 +534,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -595,9 +542,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); } /// @@ -622,9 +567,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -632,9 +575,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -642,9 +583,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -652,9 +591,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); } /// @@ -679,9 +616,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } /// @@ -706,9 +641,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.ItemsRepeaterElementClearingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementClearing += x, x => _data.ElementClearing -= x); + }, x => _data.ElementClearing += x, x => _data.ElementClearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -716,9 +649,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.ItemsRepeaterElementIndexChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementIndexChanged += x, x => _data.ElementIndexChanged -= x); + }, x => _data.ElementIndexChanged += x, x => _data.ElementIndexChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -726,9 +657,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.ItemsRepeaterElementPreparedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPrepared += x, x => _data.ElementPrepared -= x); + }, x => _data.ElementPrepared += x, x => _data.ElementPrepared -= x); } /// @@ -753,9 +682,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -780,9 +707,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MenuClosed += x, x => _data.MenuClosed -= x); + }, x => _data.MenuClosed += x, x => _data.MenuClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -790,9 +715,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MenuOpened += x, x => _data.MenuOpened -= x); + }, x => _data.MenuOpened += x, x => _data.MenuOpened -= x); } /// @@ -817,9 +740,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -827,9 +748,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerEnterItem += x, x => _data.PointerEnterItem -= x); + }, x => _data.PointerEnterItem += x, x => _data.PointerEnterItem -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -837,9 +756,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerLeaveItem += x, x => _data.PointerLeaveItem -= x); + }, x => _data.PointerLeaveItem += x, x => _data.PointerLeaveItem -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -847,9 +764,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); } /// @@ -874,9 +789,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -901,9 +814,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SpinEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Spinned += x, x => _data.Spinned -= x); + }, x => _data.Spinned += x, x => _data.Spinned -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -911,9 +822,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.NumericUpDownValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -938,9 +847,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } /// @@ -965,9 +872,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SpinEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Spin += x, x => _data.Spin -= x); + }, x => _data.Spin += x, x => _data.Spin -= x); } /// @@ -992,9 +897,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1002,9 +905,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -1029,9 +930,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -1056,9 +955,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); } /// @@ -1083,9 +980,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1093,9 +988,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Deactivated += x, x => _data.Deactivated -= x); + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1103,9 +996,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.PixelPointEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } } @@ -1148,9 +1039,7 @@ namespace Avalonia.Controls.ApplicationLifetimes { void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeExitEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Exit += x, x => _data.Exit -= x); + }, x => _data.Exit += x, x => _data.Exit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1158,9 +1047,7 @@ namespace Avalonia.Controls.ApplicationLifetimes { void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeStartupEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Startup += x, x => _data.Startup -= x); + }, x => _data.Startup += x, x => _data.Startup -= x); } /// @@ -1185,9 +1072,7 @@ namespace Avalonia.Controls.ApplicationLifetimes { void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeExitEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Exit += x, x => _data.Exit -= x); + }, x => _data.Exit += x, x => _data.Exit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1195,9 +1080,7 @@ namespace Avalonia.Controls.ApplicationLifetimes { void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeStartupEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Startup += x, x => _data.Startup -= x); + }, x => _data.Startup += x, x => _data.Startup -= x); } } @@ -1244,9 +1127,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dematerialized += x, x => _data.Dematerialized -= x); + }, x => _data.Dematerialized += x, x => _data.Dematerialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1254,9 +1135,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Materialized += x, x => _data.Materialized -= x); + }, x => _data.Materialized += x, x => _data.Materialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1264,9 +1143,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Recycled += x, x => _data.Recycled -= x); + }, x => _data.Recycled += x, x => _data.Recycled -= x); } /// @@ -1291,9 +1168,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dematerialized += x, x => _data.Dematerialized -= x); + }, x => _data.Dematerialized += x, x => _data.Dematerialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1301,9 +1176,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Materialized += x, x => _data.Materialized -= x); + }, x => _data.Materialized += x, x => _data.Materialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1311,9 +1184,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Recycled += x, x => _data.Recycled -= x); + }, x => _data.Recycled += x, x => _data.Recycled -= x); } /// @@ -1338,9 +1209,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dematerialized += x, x => _data.Dematerialized -= x); + }, x => _data.Dematerialized += x, x => _data.Dematerialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1348,9 +1217,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Materialized += x, x => _data.Materialized -= x); + }, x => _data.Materialized += x, x => _data.Materialized -= x); } } @@ -1389,9 +1256,7 @@ namespace Avalonia.Controls.Notifications { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NotificationClosed += x, x => _data.NotificationClosed -= x); + }, x => _data.NotificationClosed += x, x => _data.NotificationClosed -= x); } } @@ -1434,9 +1299,7 @@ namespace Avalonia.Controls.Platform { void Handler(global::System.Nullable obj) => eventHandler(obj); return Handler; - } - - , x => _data.Signaled += x, x => _data.Signaled -= x); + }, x => _data.Signaled += x, x => _data.Signaled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1444,9 +1307,7 @@ namespace Avalonia.Controls.Platform { void Handler(global::System.TimeSpan obj) => eventHandler(obj); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// @@ -1471,9 +1332,7 @@ namespace Avalonia.Controls.Platform { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnIsNativeMenuExportedChanged += x, x => _data.OnIsNativeMenuExportedChanged -= x); + }, x => _data.OnIsNativeMenuExportedChanged += x, x => _data.OnIsNativeMenuExportedChanged -= x); } } @@ -1544,9 +1403,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarLeftMouseButtonDown += x, x => _data.CalendarLeftMouseButtonDown -= x); + }, x => _data.CalendarLeftMouseButtonDown += x, x => _data.CalendarLeftMouseButtonDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1554,9 +1411,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarLeftMouseButtonUp += x, x => _data.CalendarLeftMouseButtonUp -= x); + }, x => _data.CalendarLeftMouseButtonUp += x, x => _data.CalendarLeftMouseButtonUp -= x); } /// @@ -1581,9 +1436,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarDayButtonMouseDown += x, x => _data.CalendarDayButtonMouseDown -= x); + }, x => _data.CalendarDayButtonMouseDown += x, x => _data.CalendarDayButtonMouseDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1591,9 +1444,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarDayButtonMouseUp += x, x => _data.CalendarDayButtonMouseUp -= x); + }, x => _data.CalendarDayButtonMouseUp += x, x => _data.CalendarDayButtonMouseUp -= x); } /// @@ -1618,9 +1469,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Controls.Primitives.TemplateAppliedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TemplateApplied += x, x => _data.TemplateApplied -= x); + }, x => _data.TemplateApplied += x, x => _data.TemplateApplied -= x); } /// @@ -1645,9 +1494,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1655,9 +1502,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -1682,9 +1527,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scroll += x, x => _data.Scroll -= x); + }, x => _data.Scroll += x, x => _data.Scroll -= x); } /// @@ -1709,9 +1552,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -1736,9 +1577,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Controls.Primitives.TemplateAppliedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TemplateApplied += x, x => _data.TemplateApplied -= x); + }, x => _data.TemplateApplied += x, x => _data.TemplateApplied -= x); } /// @@ -1763,9 +1602,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.VectorEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1773,9 +1610,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.VectorEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragDelta += x, x => _data.DragDelta -= x); + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1783,9 +1618,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.VectorEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); } /// @@ -1810,9 +1643,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Checked += x, x => _data.Checked -= x); + }, x => _data.Checked += x, x => _data.Checked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1820,9 +1651,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1830,9 +1659,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unchecked += x, x => _data.Unchecked -= x); + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); } } @@ -1875,9 +1702,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Cancel += x, x => _data.Cancel -= x); + }, x => _data.Cancel += x, x => _data.Cancel -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1885,9 +1710,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Commit += x, x => _data.Commit -= x); + }, x => _data.Commit += x, x => _data.Commit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1895,9 +1718,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -1922,9 +1743,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Cancel += x, x => _data.Cancel -= x); + }, x => _data.Cancel += x, x => _data.Cancel -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1932,9 +1751,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Commit += x, x => _data.Commit -= x); + }, x => _data.Commit += x, x => _data.Commit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1942,9 +1759,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } } @@ -1999,9 +1814,7 @@ namespace Avalonia.Input { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } /// @@ -2026,9 +1839,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.GotFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2036,9 +1847,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2046,9 +1855,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2056,9 +1863,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2066,9 +1871,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerEnter += x, x => _data.PointerEnter -= x); + }, x => _data.PointerEnter += x, x => _data.PointerEnter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2076,9 +1879,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerLeave += x, x => _data.PointerLeave -= x); + }, x => _data.PointerLeave += x, x => _data.PointerLeave -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2086,9 +1887,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2096,9 +1895,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2106,9 +1903,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2116,9 +1911,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerWheelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2126,9 +1919,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.TextInputEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextInput += x, x => _data.TextInput -= x); + }, x => _data.TextInput += x, x => _data.TextInput -= x); } /// @@ -2153,9 +1944,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MenuClosed += x, x => _data.MenuClosed -= x); + }, x => _data.MenuClosed += x, x => _data.MenuClosed -= x); } /// @@ -2180,9 +1969,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); + }, x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2190,9 +1977,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.GotFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2200,9 +1985,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2210,9 +1993,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2220,9 +2001,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2230,9 +2009,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerCaptureLostEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2240,9 +2017,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerEnter += x, x => _data.PointerEnter -= x); + }, x => _data.PointerEnter += x, x => _data.PointerEnter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2250,9 +2025,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerLeave += x, x => _data.PointerLeave -= x); + }, x => _data.PointerLeave += x, x => _data.PointerLeave -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2260,9 +2033,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2270,9 +2041,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2280,9 +2049,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2290,9 +2057,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerWheelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2300,9 +2065,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2310,9 +2073,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.TextInputEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextInput += x, x => _data.TextInput -= x); + }, x => _data.TextInput += x, x => _data.TextInput -= x); } /// @@ -2337,9 +2098,7 @@ namespace Avalonia.Input { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } } @@ -2382,9 +2141,7 @@ namespace Avalonia.Layout { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ArrangeInvalidated += x, x => _data.ArrangeInvalidated -= x); + }, x => _data.ArrangeInvalidated += x, x => _data.ArrangeInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2392,9 +2149,7 @@ namespace Avalonia.Layout { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); } /// @@ -2419,9 +2174,7 @@ namespace Avalonia.Layout { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); } } @@ -2460,9 +2213,7 @@ namespace Avalonia.LogicalTree { void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AttachedToLogicalTree += x, x => _data.AttachedToLogicalTree -= x); + }, x => _data.AttachedToLogicalTree += x, x => _data.AttachedToLogicalTree -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2470,9 +2221,7 @@ namespace Avalonia.LogicalTree { void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DetachedFromLogicalTree += x, x => _data.DetachedFromLogicalTree -= x); + }, x => _data.DetachedFromLogicalTree += x, x => _data.DetachedFromLogicalTree -= x); } } @@ -2511,9 +2260,7 @@ namespace Avalonia.Markup.Xaml.MarkupExtensions { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } } @@ -2552,9 +2299,7 @@ namespace Avalonia.Markup.Xaml.Styling { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } } @@ -2613,9 +2358,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invalidated += x, x => _data.Invalidated -= x); + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); } /// @@ -2640,9 +2383,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invalidated += x, x => _data.Invalidated -= x); + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); } /// @@ -2667,9 +2408,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } /// @@ -2694,9 +2433,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invalidated += x, x => _data.Invalidated -= x); + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); } /// @@ -2721,9 +2458,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invalidated += x, x => _data.Invalidated -= x); + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); } /// @@ -2748,9 +2483,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } } @@ -2793,9 +2526,7 @@ namespace Avalonia.Platform { void Handler() => eventHandler(global::System.Reactive.Unit.Default); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); } /// @@ -2820,9 +2551,7 @@ namespace Avalonia.Platform { void Handler(global::System.Nullable obj) => eventHandler(obj); return Handler; - } - - , x => _data.Signaled += x, x => _data.Signaled -= x); + }, x => _data.Signaled += x, x => _data.Signaled -= x); } } @@ -2877,9 +2606,7 @@ namespace Avalonia.Rendering { void Handler(global::System.TimeSpan obj) => eventHandler(obj); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// @@ -2904,9 +2631,7 @@ namespace Avalonia.Rendering { void Handler(object sender, global::Avalonia.Rendering.SceneInvalidatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); + }, x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); } /// @@ -2931,9 +2656,7 @@ namespace Avalonia.Rendering { void Handler(object sender, global::Avalonia.Rendering.SceneInvalidatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); + }, x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); } /// @@ -2958,9 +2681,7 @@ namespace Avalonia.Rendering { void Handler(object sender, global::Avalonia.Rendering.SceneInvalidatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); + }, x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); } /// @@ -2985,9 +2706,7 @@ namespace Avalonia.Rendering { void Handler(global::System.TimeSpan obj) => eventHandler(obj); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } } @@ -3030,9 +2749,7 @@ namespace Avalonia.Styling { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } /// @@ -3057,9 +2774,7 @@ namespace Avalonia.Styling { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3067,9 +2782,7 @@ namespace Avalonia.Styling { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } } @@ -3108,9 +2821,7 @@ namespace Avalonia.Threading { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } } @@ -3149,9 +2860,7 @@ namespace Avalonia.VisualTree { void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AttachedToVisualTree += x, x => _data.AttachedToVisualTree -= x); + }, x => _data.AttachedToVisualTree += x, x => _data.AttachedToVisualTree -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3159,8 +2868,6 @@ namespace Avalonia.VisualTree { void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DetachedFromVisualTree += x, x => _data.DetachedFromVisualTree -= x); + }, x => _data.DetachedFromVisualTree += x, x => _data.DetachedFromVisualTree -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.netcoreapp2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.net5.0.approved.txt similarity index 93% rename from src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.netcoreapp2.0.approved.txt rename to src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.net5.0.approved.txt index 8427975..d31db4c 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.netcoreapp2.0.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.net5.0.approved.txt @@ -1,3 +1,4 @@ + using global::System; using global::System.Reactive; using global::System.Reactive.Linq; @@ -59,9 +60,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } /// @@ -86,9 +85,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.AvaloniaPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -113,9 +110,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.AvaloniaPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InheritablePropertyChanged += x, x => _data.InheritablePropertyChanged -= x); + }, x => _data.InheritablePropertyChanged += x, x => _data.InheritablePropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -123,9 +118,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.AvaloniaPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -150,9 +143,7 @@ namespace Avalonia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Initialized += x, x => _data.Initialized -= x); + }, x => _data.Initialized += x, x => _data.Initialized -= x); } /// @@ -177,9 +168,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AttachedToLogicalTree += x, x => _data.AttachedToLogicalTree -= x); + }, x => _data.AttachedToLogicalTree += x, x => _data.AttachedToLogicalTree -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -187,9 +176,7 @@ namespace Avalonia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -197,9 +184,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DetachedFromLogicalTree += x, x => _data.DetachedFromLogicalTree -= x); + }, x => _data.DetachedFromLogicalTree += x, x => _data.DetachedFromLogicalTree -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -207,9 +192,7 @@ namespace Avalonia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Initialized += x, x => _data.Initialized -= x); + }, x => _data.Initialized += x, x => _data.Initialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -217,9 +200,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } /// @@ -244,9 +225,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AttachedToVisualTree += x, x => _data.AttachedToVisualTree -= x); + }, x => _data.AttachedToVisualTree += x, x => _data.AttachedToVisualTree -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -254,9 +233,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DetachedFromVisualTree += x, x => _data.DetachedFromVisualTree -= x); + }, x => _data.DetachedFromVisualTree += x, x => _data.DetachedFromVisualTree -= x); } } @@ -295,9 +272,7 @@ namespace Avalonia.Collections { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -305,9 +280,7 @@ namespace Avalonia.Collections { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } } @@ -414,9 +387,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -424,9 +395,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownClosing += x, x => _data.DropDownClosing -= x); + }, x => _data.DropDownClosing += x, x => _data.DropDownClosing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -434,9 +403,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -444,9 +411,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -454,9 +419,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.PopulatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Populated += x, x => _data.Populated -= x); + }, x => _data.Populated += x, x => _data.Populated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -464,9 +427,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.PopulatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Populating += x, x => _data.Populating -= x); + }, x => _data.Populating += x, x => _data.Populating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -474,9 +435,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -484,9 +443,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -511,9 +468,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -538,9 +493,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -548,9 +501,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -558,9 +509,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); } /// @@ -585,9 +534,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -595,9 +542,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); } /// @@ -622,9 +567,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -632,9 +575,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -642,9 +583,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -652,9 +591,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); } /// @@ -679,9 +616,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } /// @@ -706,9 +641,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.ItemsRepeaterElementClearingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementClearing += x, x => _data.ElementClearing -= x); + }, x => _data.ElementClearing += x, x => _data.ElementClearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -716,9 +649,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.ItemsRepeaterElementIndexChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementIndexChanged += x, x => _data.ElementIndexChanged -= x); + }, x => _data.ElementIndexChanged += x, x => _data.ElementIndexChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -726,9 +657,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.ItemsRepeaterElementPreparedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPrepared += x, x => _data.ElementPrepared -= x); + }, x => _data.ElementPrepared += x, x => _data.ElementPrepared -= x); } /// @@ -753,9 +682,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -780,9 +707,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MenuClosed += x, x => _data.MenuClosed -= x); + }, x => _data.MenuClosed += x, x => _data.MenuClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -790,9 +715,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MenuOpened += x, x => _data.MenuOpened -= x); + }, x => _data.MenuOpened += x, x => _data.MenuOpened -= x); } /// @@ -817,9 +740,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -827,9 +748,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerEnterItem += x, x => _data.PointerEnterItem -= x); + }, x => _data.PointerEnterItem += x, x => _data.PointerEnterItem -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -837,9 +756,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerLeaveItem += x, x => _data.PointerLeaveItem -= x); + }, x => _data.PointerLeaveItem += x, x => _data.PointerLeaveItem -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -847,9 +764,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); } /// @@ -874,9 +789,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -901,9 +814,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SpinEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Spinned += x, x => _data.Spinned -= x); + }, x => _data.Spinned += x, x => _data.Spinned -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -911,9 +822,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.NumericUpDownValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -938,9 +847,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } /// @@ -965,9 +872,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SpinEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Spin += x, x => _data.Spin -= x); + }, x => _data.Spin += x, x => _data.Spin -= x); } /// @@ -992,9 +897,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1002,9 +905,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -1029,9 +930,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -1056,9 +955,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); } /// @@ -1083,9 +980,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1093,9 +988,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Deactivated += x, x => _data.Deactivated -= x); + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1103,9 +996,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.PixelPointEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } } @@ -1148,9 +1039,7 @@ namespace Avalonia.Controls.ApplicationLifetimes { void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeExitEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Exit += x, x => _data.Exit -= x); + }, x => _data.Exit += x, x => _data.Exit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1158,9 +1047,7 @@ namespace Avalonia.Controls.ApplicationLifetimes { void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeStartupEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Startup += x, x => _data.Startup -= x); + }, x => _data.Startup += x, x => _data.Startup -= x); } /// @@ -1185,9 +1072,7 @@ namespace Avalonia.Controls.ApplicationLifetimes { void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeExitEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Exit += x, x => _data.Exit -= x); + }, x => _data.Exit += x, x => _data.Exit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1195,9 +1080,7 @@ namespace Avalonia.Controls.ApplicationLifetimes { void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeStartupEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Startup += x, x => _data.Startup -= x); + }, x => _data.Startup += x, x => _data.Startup -= x); } } @@ -1244,9 +1127,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dematerialized += x, x => _data.Dematerialized -= x); + }, x => _data.Dematerialized += x, x => _data.Dematerialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1254,9 +1135,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Materialized += x, x => _data.Materialized -= x); + }, x => _data.Materialized += x, x => _data.Materialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1264,9 +1143,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Recycled += x, x => _data.Recycled -= x); + }, x => _data.Recycled += x, x => _data.Recycled -= x); } /// @@ -1291,9 +1168,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dematerialized += x, x => _data.Dematerialized -= x); + }, x => _data.Dematerialized += x, x => _data.Dematerialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1301,9 +1176,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Materialized += x, x => _data.Materialized -= x); + }, x => _data.Materialized += x, x => _data.Materialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1311,9 +1184,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Recycled += x, x => _data.Recycled -= x); + }, x => _data.Recycled += x, x => _data.Recycled -= x); } /// @@ -1338,9 +1209,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dematerialized += x, x => _data.Dematerialized -= x); + }, x => _data.Dematerialized += x, x => _data.Dematerialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1348,9 +1217,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Materialized += x, x => _data.Materialized -= x); + }, x => _data.Materialized += x, x => _data.Materialized -= x); } } @@ -1389,9 +1256,7 @@ namespace Avalonia.Controls.Notifications { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NotificationClosed += x, x => _data.NotificationClosed -= x); + }, x => _data.NotificationClosed += x, x => _data.NotificationClosed -= x); } } @@ -1434,9 +1299,7 @@ namespace Avalonia.Controls.Platform { void Handler(global::System.Nullable obj) => eventHandler(obj); return Handler; - } - - , x => _data.Signaled += x, x => _data.Signaled -= x); + }, x => _data.Signaled += x, x => _data.Signaled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1444,9 +1307,7 @@ namespace Avalonia.Controls.Platform { void Handler(global::System.TimeSpan obj) => eventHandler(obj); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// @@ -1471,9 +1332,7 @@ namespace Avalonia.Controls.Platform { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnIsNativeMenuExportedChanged += x, x => _data.OnIsNativeMenuExportedChanged -= x); + }, x => _data.OnIsNativeMenuExportedChanged += x, x => _data.OnIsNativeMenuExportedChanged -= x); } } @@ -1544,9 +1403,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarLeftMouseButtonDown += x, x => _data.CalendarLeftMouseButtonDown -= x); + }, x => _data.CalendarLeftMouseButtonDown += x, x => _data.CalendarLeftMouseButtonDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1554,9 +1411,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarLeftMouseButtonUp += x, x => _data.CalendarLeftMouseButtonUp -= x); + }, x => _data.CalendarLeftMouseButtonUp += x, x => _data.CalendarLeftMouseButtonUp -= x); } /// @@ -1581,9 +1436,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarDayButtonMouseDown += x, x => _data.CalendarDayButtonMouseDown -= x); + }, x => _data.CalendarDayButtonMouseDown += x, x => _data.CalendarDayButtonMouseDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1591,9 +1444,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarDayButtonMouseUp += x, x => _data.CalendarDayButtonMouseUp -= x); + }, x => _data.CalendarDayButtonMouseUp += x, x => _data.CalendarDayButtonMouseUp -= x); } /// @@ -1618,9 +1469,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Controls.Primitives.TemplateAppliedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TemplateApplied += x, x => _data.TemplateApplied -= x); + }, x => _data.TemplateApplied += x, x => _data.TemplateApplied -= x); } /// @@ -1645,9 +1494,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1655,9 +1502,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -1682,9 +1527,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scroll += x, x => _data.Scroll -= x); + }, x => _data.Scroll += x, x => _data.Scroll -= x); } /// @@ -1709,9 +1552,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -1736,9 +1577,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Controls.Primitives.TemplateAppliedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TemplateApplied += x, x => _data.TemplateApplied -= x); + }, x => _data.TemplateApplied += x, x => _data.TemplateApplied -= x); } /// @@ -1763,9 +1602,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.VectorEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1773,9 +1610,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.VectorEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragDelta += x, x => _data.DragDelta -= x); + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1783,9 +1618,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.VectorEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); } /// @@ -1810,9 +1643,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Checked += x, x => _data.Checked -= x); + }, x => _data.Checked += x, x => _data.Checked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1820,9 +1651,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1830,9 +1659,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unchecked += x, x => _data.Unchecked -= x); + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); } } @@ -1875,9 +1702,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Cancel += x, x => _data.Cancel -= x); + }, x => _data.Cancel += x, x => _data.Cancel -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1885,9 +1710,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Commit += x, x => _data.Commit -= x); + }, x => _data.Commit += x, x => _data.Commit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1895,9 +1718,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -1922,9 +1743,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Cancel += x, x => _data.Cancel -= x); + }, x => _data.Cancel += x, x => _data.Cancel -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1932,9 +1751,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Commit += x, x => _data.Commit -= x); + }, x => _data.Commit += x, x => _data.Commit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1942,9 +1759,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } } @@ -1999,9 +1814,7 @@ namespace Avalonia.Input { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } /// @@ -2026,9 +1839,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.GotFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2036,9 +1847,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2046,9 +1855,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2056,9 +1863,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2066,9 +1871,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerEnter += x, x => _data.PointerEnter -= x); + }, x => _data.PointerEnter += x, x => _data.PointerEnter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2076,9 +1879,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerLeave += x, x => _data.PointerLeave -= x); + }, x => _data.PointerLeave += x, x => _data.PointerLeave -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2086,9 +1887,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2096,9 +1895,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2106,9 +1903,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2116,9 +1911,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerWheelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2126,9 +1919,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.TextInputEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextInput += x, x => _data.TextInput -= x); + }, x => _data.TextInput += x, x => _data.TextInput -= x); } /// @@ -2153,9 +1944,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MenuClosed += x, x => _data.MenuClosed -= x); + }, x => _data.MenuClosed += x, x => _data.MenuClosed -= x); } /// @@ -2180,9 +1969,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); + }, x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2190,9 +1977,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.GotFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2200,9 +1985,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2210,9 +1993,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2220,9 +2001,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2230,9 +2009,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerCaptureLostEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2240,9 +2017,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerEnter += x, x => _data.PointerEnter -= x); + }, x => _data.PointerEnter += x, x => _data.PointerEnter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2250,9 +2025,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerLeave += x, x => _data.PointerLeave -= x); + }, x => _data.PointerLeave += x, x => _data.PointerLeave -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2260,9 +2033,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2270,9 +2041,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2280,9 +2049,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2290,9 +2057,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerWheelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2300,9 +2065,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2310,9 +2073,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.TextInputEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextInput += x, x => _data.TextInput -= x); + }, x => _data.TextInput += x, x => _data.TextInput -= x); } /// @@ -2337,9 +2098,7 @@ namespace Avalonia.Input { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } } @@ -2382,9 +2141,7 @@ namespace Avalonia.Layout { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ArrangeInvalidated += x, x => _data.ArrangeInvalidated -= x); + }, x => _data.ArrangeInvalidated += x, x => _data.ArrangeInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2392,9 +2149,7 @@ namespace Avalonia.Layout { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); } /// @@ -2419,9 +2174,7 @@ namespace Avalonia.Layout { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); } } @@ -2460,9 +2213,7 @@ namespace Avalonia.LogicalTree { void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AttachedToLogicalTree += x, x => _data.AttachedToLogicalTree -= x); + }, x => _data.AttachedToLogicalTree += x, x => _data.AttachedToLogicalTree -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2470,9 +2221,7 @@ namespace Avalonia.LogicalTree { void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DetachedFromLogicalTree += x, x => _data.DetachedFromLogicalTree -= x); + }, x => _data.DetachedFromLogicalTree += x, x => _data.DetachedFromLogicalTree -= x); } } @@ -2511,9 +2260,7 @@ namespace Avalonia.Markup.Xaml.MarkupExtensions { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } } @@ -2552,9 +2299,7 @@ namespace Avalonia.Markup.Xaml.Styling { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } } @@ -2613,9 +2358,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invalidated += x, x => _data.Invalidated -= x); + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); } /// @@ -2640,9 +2383,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invalidated += x, x => _data.Invalidated -= x); + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); } /// @@ -2667,9 +2408,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } /// @@ -2694,9 +2433,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invalidated += x, x => _data.Invalidated -= x); + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); } /// @@ -2721,9 +2458,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invalidated += x, x => _data.Invalidated -= x); + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); } /// @@ -2748,9 +2483,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } } @@ -2793,9 +2526,7 @@ namespace Avalonia.Platform { void Handler() => eventHandler(global::System.Reactive.Unit.Default); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); } /// @@ -2820,9 +2551,7 @@ namespace Avalonia.Platform { void Handler(global::System.Nullable obj) => eventHandler(obj); return Handler; - } - - , x => _data.Signaled += x, x => _data.Signaled -= x); + }, x => _data.Signaled += x, x => _data.Signaled -= x); } } @@ -2877,9 +2606,7 @@ namespace Avalonia.Rendering { void Handler(global::System.TimeSpan obj) => eventHandler(obj); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// @@ -2904,9 +2631,7 @@ namespace Avalonia.Rendering { void Handler(object sender, global::Avalonia.Rendering.SceneInvalidatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); + }, x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); } /// @@ -2931,9 +2656,7 @@ namespace Avalonia.Rendering { void Handler(object sender, global::Avalonia.Rendering.SceneInvalidatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); + }, x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); } /// @@ -2958,9 +2681,7 @@ namespace Avalonia.Rendering { void Handler(object sender, global::Avalonia.Rendering.SceneInvalidatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); + }, x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); } /// @@ -2985,9 +2706,7 @@ namespace Avalonia.Rendering { void Handler(global::System.TimeSpan obj) => eventHandler(obj); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } } @@ -3030,9 +2749,7 @@ namespace Avalonia.Styling { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } /// @@ -3057,9 +2774,7 @@ namespace Avalonia.Styling { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3067,9 +2782,7 @@ namespace Avalonia.Styling { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } } @@ -3108,9 +2821,7 @@ namespace Avalonia.Threading { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } } @@ -3149,9 +2860,7 @@ namespace Avalonia.VisualTree { void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AttachedToVisualTree += x, x => _data.AttachedToVisualTree -= x); + }, x => _data.AttachedToVisualTree += x, x => _data.AttachedToVisualTree -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3159,8 +2868,6 @@ namespace Avalonia.VisualTree { void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DetachedFromVisualTree += x, x => _data.DetachedFromVisualTree -= x); + }, x => _data.DetachedFromVisualTree += x, x => _data.DetachedFromVisualTree -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.netcoreapp3.1.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.netcoreapp3.1.approved.txt new file mode 100644 index 0000000..d31db4c --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.netcoreapp3.1.approved.txt @@ -0,0 +1,2873 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Avalonia +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::Avalonia.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAvaloniaObjectEvents Events(this global::Avalonia.AvaloniaObject item) => new RxAvaloniaObjectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIAvaloniaObjectEvents Events(this global::Avalonia.IAvaloniaObject item) => new RxIAvaloniaObjectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIStyledElementEvents Events(this global::Avalonia.IStyledElement item) => new RxIStyledElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStyledElementEvents Events(this global::Avalonia.StyledElement item) => new RxStyledElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualEvents Events(this global::Avalonia.Visual item) => new RxVisualEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents : global::Avalonia.RxAvaloniaObjectEvents + { + private readonly global::Avalonia.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::Avalonia.Application data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResourcesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.ResourcesChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAvaloniaObjectEvents + { + private readonly global::Avalonia.AvaloniaObject _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAvaloniaObjectEvents(global::Avalonia.AvaloniaObject data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.AvaloniaPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.AvaloniaPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIAvaloniaObjectEvents + { + private readonly global::Avalonia.IAvaloniaObject _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIAvaloniaObjectEvents(global::Avalonia.IAvaloniaObject data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InheritablePropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.AvaloniaPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.AvaloniaPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InheritablePropertyChanged += x, x => _data.InheritablePropertyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.AvaloniaPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.AvaloniaPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIStyledElementEvents + { + private readonly global::Avalonia.IStyledElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIStyledElementEvents(global::Avalonia.IStyledElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStyledElementEvents : global::Avalonia.RxAvaloniaObjectEvents + { + private readonly global::Avalonia.StyledElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStyledElementEvents(global::Avalonia.StyledElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttachedToLogicalTree => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttachedToLogicalTree += x, x => _data.AttachedToLogicalTree -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DetachedFromLogicalTree => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DetachedFromLogicalTree += x, x => _data.DetachedFromLogicalTree -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResourcesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.ResourcesChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualEvents : global::Avalonia.RxStyledElementEvents + { + private readonly global::Avalonia.Visual _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualEvents(global::Avalonia.Visual data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttachedToVisualTree => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.VisualTreeAttachmentEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttachedToVisualTree += x, x => _data.AttachedToVisualTree -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DetachedFromVisualTree => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.VisualTreeAttachmentEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DetachedFromVisualTree += x, x => _data.DetachedFromVisualTree -= x); + } +} + +namespace Avalonia.Collections +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAvaloniaDictionaryEvents Events(this global::Avalonia.Collections.AvaloniaDictionary item) => new RxAvaloniaDictionaryEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAvaloniaDictionaryEvents + { + private readonly global::Avalonia.Collections.AvaloniaDictionary _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAvaloniaDictionaryEvents(global::Avalonia.Collections.AvaloniaDictionary data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } +} + +namespace Avalonia.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteBoxEvents Events(this global::Avalonia.Controls.AutoCompleteBox item) => new RxAutoCompleteBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::Avalonia.Controls.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::Avalonia.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::Avalonia.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::Avalonia.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIResourceProviderEvents Events(this global::Avalonia.Controls.IResourceProvider item) => new RxIResourceProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemsRepeaterEvents Events(this global::Avalonia.Controls.ItemsRepeater item) => new RxItemsRepeaterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemsSourceViewEvents Events(this global::Avalonia.Controls.ItemsSourceView item) => new RxItemsSourceViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuBaseEvents Events(this global::Avalonia.Controls.MenuBase item) => new RxMenuBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::Avalonia.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNativeMenuItemEvents Events(this global::Avalonia.Controls.NativeMenuItem item) => new RxNativeMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::Avalonia.Controls.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxResourceDictionaryEvents Events(this global::Avalonia.Controls.ResourceDictionary item) => new RxResourceDictionaryEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpinnerEvents Events(this global::Avalonia.Controls.Spinner item) => new RxSpinnerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTopLevelEvents Events(this global::Avalonia.Controls.TopLevel item) => new RxTopLevelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::Avalonia.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::Avalonia.Controls.Window item) => new RxWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowBaseEvents Events(this global::Avalonia.Controls.WindowBase item) => new RxWindowBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteBoxEvents : global::Avalonia.Controls.Primitives.RxTemplatedControlEvents + { + private readonly global::Avalonia.Controls.AutoCompleteBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteBoxEvents(global::Avalonia.Controls.AutoCompleteBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosing => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.CancelEventArgs>(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosing += x, x => _data.DropDownClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.CancelEventArgs>(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Populated => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.PopulatedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.PopulatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Populated += x, x => _data.Populated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Populating => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.PopulatingEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.PopulatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Populating += x, x => _data.Populating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::Avalonia.Controls.Primitives.RxTemplatedControlEvents + { + private readonly global::Avalonia.Controls.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::Avalonia.Controls.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::Avalonia.Controls.Primitives.RxTemplatedControlEvents + { + private readonly global::Avalonia.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::Avalonia.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::Avalonia.Controls.RxMenuBaseEvents + { + private readonly global::Avalonia.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::Avalonia.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::Avalonia.Controls.Primitives.RxTemplatedControlEvents + { + private readonly global::Avalonia.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::Avalonia.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIResourceProviderEvents + { + private readonly global::Avalonia.Controls.IResourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIResourceProviderEvents(global::Avalonia.Controls.IResourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResourcesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.ResourcesChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemsRepeaterEvents : global::Avalonia.Input.RxInputElementEvents + { + private readonly global::Avalonia.Controls.ItemsRepeater _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemsRepeaterEvents(global::Avalonia.Controls.ItemsRepeater data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ElementClearing => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.ItemsRepeaterElementClearingEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.ItemsRepeaterElementClearingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ElementClearing += x, x => _data.ElementClearing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ElementIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.ItemsRepeaterElementIndexChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.ItemsRepeaterElementIndexChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ElementIndexChanged += x, x => _data.ElementIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ElementPrepared => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.ItemsRepeaterElementPreparedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.ItemsRepeaterElementPreparedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ElementPrepared += x, x => _data.ElementPrepared -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemsSourceViewEvents + { + private readonly global::Avalonia.Controls.ItemsSourceView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemsSourceViewEvents(global::Avalonia.Controls.ItemsSourceView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuBaseEvents : global::Avalonia.Controls.Primitives.RxSelectingItemsControlEvents + { + private readonly global::Avalonia.Controls.MenuBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuBaseEvents(global::Avalonia.Controls.MenuBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuClosed += x, x => _data.MenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuOpened => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuOpened += x, x => _data.MenuOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::Avalonia.Controls.Primitives.RxSelectingItemsControlEvents + { + private readonly global::Avalonia.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::Avalonia.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerEnterItem => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerEnterItem += x, x => _data.PointerEnterItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerLeaveItem => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerLeaveItem += x, x => _data.PointerLeaveItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNativeMenuItemEvents : global::Avalonia.RxAvaloniaObjectEvents + { + private readonly global::Avalonia.Controls.NativeMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNativeMenuItemEvents(global::Avalonia.Controls.NativeMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Clicked += x, x => _data.Clicked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::Avalonia.Controls.Primitives.RxTemplatedControlEvents + { + private readonly global::Avalonia.Controls.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::Avalonia.Controls.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Spinned => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.SpinEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.SpinEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Spinned += x, x => _data.Spinned -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.NumericUpDownValueChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.NumericUpDownValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxResourceDictionaryEvents : global::Avalonia.Collections.RxAvaloniaDictionaryEvents + { + private readonly global::Avalonia.Controls.ResourceDictionary _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxResourceDictionaryEvents(global::Avalonia.Controls.ResourceDictionary data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResourcesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.ResourcesChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpinnerEvents : global::Avalonia.Controls.Primitives.RxTemplatedControlEvents + { + private readonly global::Avalonia.Controls.Spinner _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpinnerEvents(global::Avalonia.Controls.Spinner data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Spin => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.SpinEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.SpinEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Spin += x, x => _data.Spin -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTopLevelEvents : global::Avalonia.Controls.Primitives.RxTemplatedControlEvents + { + private readonly global::Avalonia.Controls.TopLevel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTopLevelEvents(global::Avalonia.Controls.TopLevel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::Avalonia.Controls.Primitives.RxTemplatedControlEvents + { + private readonly global::Avalonia.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::Avalonia.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::Avalonia.Controls.RxWindowBaseEvents + { + private readonly global::Avalonia.Controls.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::Avalonia.Controls.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.CancelEventArgs>(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowBaseEvents : global::Avalonia.Controls.RxTopLevelEvents + { + private readonly global::Avalonia.Controls.WindowBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowBaseEvents(global::Avalonia.Controls.WindowBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.PixelPointEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.PixelPointEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } +} + +namespace Avalonia.Controls.ApplicationLifetimes +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClassicDesktopStyleApplicationLifetimeEvents Events(this global::Avalonia.Controls.ApplicationLifetimes.ClassicDesktopStyleApplicationLifetime item) => new RxClassicDesktopStyleApplicationLifetimeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIControlledApplicationLifetimeEvents Events(this global::Avalonia.Controls.ApplicationLifetimes.IControlledApplicationLifetime item) => new RxIControlledApplicationLifetimeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClassicDesktopStyleApplicationLifetimeEvents + { + private readonly global::Avalonia.Controls.ApplicationLifetimes.ClassicDesktopStyleApplicationLifetime _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClassicDesktopStyleApplicationLifetimeEvents(global::Avalonia.Controls.ApplicationLifetimes.ClassicDesktopStyleApplicationLifetime data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeExitEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeStartupEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeStartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIControlledApplicationLifetimeEvents + { + private readonly global::Avalonia.Controls.ApplicationLifetimes.IControlledApplicationLifetime _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIControlledApplicationLifetimeEvents(global::Avalonia.Controls.ApplicationLifetimes.IControlledApplicationLifetime data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeExitEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeStartupEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeStartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } +} + +namespace Avalonia.Controls.Generators +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIItemContainerGeneratorEvents Events(this global::Avalonia.Controls.Generators.IItemContainerGenerator item) => new RxIItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::Avalonia.Controls.Generators.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeContainerIndexEvents Events(this global::Avalonia.Controls.Generators.TreeContainerIndex item) => new RxTreeContainerIndexEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIItemContainerGeneratorEvents + { + private readonly global::Avalonia.Controls.Generators.IItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIItemContainerGeneratorEvents(global::Avalonia.Controls.Generators.IItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Dematerialized => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.Generators.ItemContainerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Dematerialized += x, x => _data.Dematerialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Materialized => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.Generators.ItemContainerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Materialized += x, x => _data.Materialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Recycled => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.Generators.ItemContainerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Recycled += x, x => _data.Recycled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::Avalonia.Controls.Generators.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::Avalonia.Controls.Generators.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Dematerialized => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.Generators.ItemContainerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Dematerialized += x, x => _data.Dematerialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Materialized => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.Generators.ItemContainerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Materialized += x, x => _data.Materialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Recycled => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.Generators.ItemContainerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Recycled += x, x => _data.Recycled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeContainerIndexEvents + { + private readonly global::Avalonia.Controls.Generators.TreeContainerIndex _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeContainerIndexEvents(global::Avalonia.Controls.Generators.TreeContainerIndex data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Dematerialized => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.Generators.ItemContainerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Dematerialized += x, x => _data.Dematerialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Materialized => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.Generators.ItemContainerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Materialized += x, x => _data.Materialized -= x); + } +} + +namespace Avalonia.Controls.Notifications +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotificationCardEvents Events(this global::Avalonia.Controls.Notifications.NotificationCard item) => new RxNotificationCardEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotificationCardEvents : global::Avalonia.Controls.Primitives.RxTemplatedControlEvents + { + private readonly global::Avalonia.Controls.Notifications.NotificationCard _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotificationCardEvents(global::Avalonia.Controls.Notifications.NotificationCard data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NotificationClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NotificationClosed += x, x => _data.NotificationClosed -= x); + } +} + +namespace Avalonia.Controls.Platform +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInternalPlatformThreadingInterfaceEvents Events(this global::Avalonia.Controls.Platform.InternalPlatformThreadingInterface item) => new RxInternalPlatformThreadingInterfaceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxITopLevelNativeMenuExporterEvents Events(this global::Avalonia.Controls.Platform.ITopLevelNativeMenuExporter item) => new RxITopLevelNativeMenuExporterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInternalPlatformThreadingInterfaceEvents + { + private readonly global::Avalonia.Controls.Platform.InternalPlatformThreadingInterface _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInternalPlatformThreadingInterfaceEvents(global::Avalonia.Controls.Platform.InternalPlatformThreadingInterface data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> Signaled => global::System.Reactive.Linq.Observable.FromEvent>, global::System.Nullable>(eventHandler => + { + void Handler(global::System.Nullable obj) => eventHandler(obj); + return Handler; + }, x => _data.Signaled += x, x => _data.Signaled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent, global::System.TimeSpan>(eventHandler => + { + void Handler(global::System.TimeSpan obj) => eventHandler(obj); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxITopLevelNativeMenuExporterEvents + { + private readonly global::Avalonia.Controls.Platform.ITopLevelNativeMenuExporter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxITopLevelNativeMenuExporterEvents(global::Avalonia.Controls.Platform.ITopLevelNativeMenuExporter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OnIsNativeMenuExportedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OnIsNativeMenuExportedChanged += x, x => _data.OnIsNativeMenuExportedChanged -= x); + } +} + +namespace Avalonia.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarButtonEvents Events(this global::Avalonia.Controls.Primitives.CalendarButton item) => new RxCalendarButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDayButtonEvents Events(this global::Avalonia.Controls.Primitives.CalendarDayButton item) => new RxCalendarDayButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPopupHostEvents Events(this global::Avalonia.Controls.Primitives.IPopupHost item) => new RxIPopupHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::Avalonia.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::Avalonia.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectingItemsControlEvents Events(this global::Avalonia.Controls.Primitives.SelectingItemsControl item) => new RxSelectingItemsControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTemplatedControlEvents Events(this global::Avalonia.Controls.Primitives.TemplatedControl item) => new RxTemplatedControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::Avalonia.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::Avalonia.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarButtonEvents : global::Avalonia.Controls.RxButtonEvents + { + private readonly global::Avalonia.Controls.Primitives.CalendarButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarButtonEvents(global::Avalonia.Controls.Primitives.CalendarButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarLeftMouseButtonDown => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerPressedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarLeftMouseButtonDown += x, x => _data.CalendarLeftMouseButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarLeftMouseButtonUp => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerReleasedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarLeftMouseButtonUp += x, x => _data.CalendarLeftMouseButtonUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDayButtonEvents : global::Avalonia.Controls.RxButtonEvents + { + private readonly global::Avalonia.Controls.Primitives.CalendarDayButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDayButtonEvents(global::Avalonia.Controls.Primitives.CalendarDayButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarDayButtonMouseDown => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerPressedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarDayButtonMouseDown += x, x => _data.CalendarDayButtonMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarDayButtonMouseUp => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerReleasedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarDayButtonMouseUp += x, x => _data.CalendarDayButtonMouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPopupHostEvents + { + private readonly global::Avalonia.Controls.Primitives.IPopupHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPopupHostEvents(global::Avalonia.Controls.Primitives.IPopupHost data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TemplateApplied => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.Primitives.TemplateAppliedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.Primitives.TemplateAppliedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TemplateApplied += x, x => _data.TemplateApplied -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::Avalonia.Input.RxInputElementEvents + { + private readonly global::Avalonia.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::Avalonia.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::Avalonia.Controls.Primitives.RxTemplatedControlEvents + { + private readonly global::Avalonia.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::Avalonia.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.Primitives.ScrollEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectingItemsControlEvents : global::Avalonia.Controls.Primitives.RxTemplatedControlEvents + { + private readonly global::Avalonia.Controls.Primitives.SelectingItemsControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectingItemsControlEvents(global::Avalonia.Controls.Primitives.SelectingItemsControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTemplatedControlEvents : global::Avalonia.Input.RxInputElementEvents + { + private readonly global::Avalonia.Controls.Primitives.TemplatedControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTemplatedControlEvents(global::Avalonia.Controls.Primitives.TemplatedControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TemplateApplied => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.Primitives.TemplateAppliedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.Primitives.TemplateAppliedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TemplateApplied += x, x => _data.TemplateApplied -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::Avalonia.Controls.Primitives.RxTemplatedControlEvents + { + private readonly global::Avalonia.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::Avalonia.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.VectorEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.VectorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.VectorEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.VectorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.VectorEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.VectorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::Avalonia.Controls.RxButtonEvents + { + private readonly global::Avalonia.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::Avalonia.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace Avalonia.Controls.Utils +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxISelectionAdapterEvents Events(this global::Avalonia.Controls.Utils.ISelectionAdapter item) => new RxISelectionAdapterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectingItemsControlSelectionAdapterEvents Events(this global::Avalonia.Controls.Utils.SelectingItemsControlSelectionAdapter item) => new RxSelectingItemsControlSelectionAdapterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxISelectionAdapterEvents + { + private readonly global::Avalonia.Controls.Utils.ISelectionAdapter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxISelectionAdapterEvents(global::Avalonia.Controls.Utils.ISelectionAdapter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Cancel => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Cancel += x, x => _data.Cancel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Commit => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Commit += x, x => _data.Commit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectingItemsControlSelectionAdapterEvents + { + private readonly global::Avalonia.Controls.Utils.SelectingItemsControlSelectionAdapter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectingItemsControlSelectionAdapterEvents(global::Avalonia.Controls.Utils.SelectingItemsControlSelectionAdapter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Cancel => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Cancel += x, x => _data.Cancel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Commit => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Commit += x, x => _data.Commit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } +} + +namespace Avalonia.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICloseableEvents Events(this global::Avalonia.Input.ICloseable item) => new RxICloseableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::Avalonia.Input.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIMainMenuEvents Events(this global::Avalonia.Input.IMainMenu item) => new RxIMainMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputElementEvents Events(this global::Avalonia.Input.InputElement item) => new RxInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxKeyboardDeviceEvents Events(this global::Avalonia.Input.KeyboardDevice item) => new RxKeyboardDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICloseableEvents + { + private readonly global::Avalonia.Input.ICloseable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICloseableEvents(global::Avalonia.Input.ICloseable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::Avalonia.Input.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::Avalonia.Input.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.GotFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.GotFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.KeyEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.KeyEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerEnter => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerEnter += x, x => _data.PointerEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerLeave => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerLeave += x, x => _data.PointerLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerPressedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerReleasedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerWheelEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.TextInputEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.TextInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIMainMenuEvents + { + private readonly global::Avalonia.Input.IMainMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIMainMenuEvents(global::Avalonia.Input.IMainMenu data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuClosed += x, x => _data.MenuClosed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputElementEvents : global::Avalonia.Layout.RxLayoutableEvents + { + private readonly global::Avalonia.Input.InputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputElementEvents(global::Avalonia.Input.InputElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.GotFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.GotFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.KeyEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.KeyEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerCaptureLostEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerCaptureLostEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerEnter => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerEnter += x, x => _data.PointerEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerLeave => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerLeave += x, x => _data.PointerLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerPressedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerReleasedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.PointerWheelEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.PointerWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Interactivity.RoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tapped += x, x => _data.Tapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Input.TextInputEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Input.TextInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxKeyboardDeviceEvents + { + private readonly global::Avalonia.Input.KeyboardDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxKeyboardDeviceEvents(global::Avalonia.Input.KeyboardDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } +} + +namespace Avalonia.Layout +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAttachedLayoutEvents Events(this global::Avalonia.Layout.AttachedLayout item) => new RxAttachedLayoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLayoutableEvents Events(this global::Avalonia.Layout.Layoutable item) => new RxLayoutableEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAttachedLayoutEvents : global::Avalonia.RxAvaloniaObjectEvents + { + private readonly global::Avalonia.Layout.AttachedLayout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAttachedLayoutEvents(global::Avalonia.Layout.AttachedLayout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ArrangeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ArrangeInvalidated += x, x => _data.ArrangeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLayoutableEvents : global::Avalonia.RxVisualEvents + { + private readonly global::Avalonia.Layout.Layoutable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLayoutableEvents(global::Avalonia.Layout.Layoutable data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + } +} + +namespace Avalonia.LogicalTree +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxILogicalEvents Events(this global::Avalonia.LogicalTree.ILogical item) => new RxILogicalEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxILogicalEvents + { + private readonly global::Avalonia.LogicalTree.ILogical _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxILogicalEvents(global::Avalonia.LogicalTree.ILogical data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttachedToLogicalTree => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttachedToLogicalTree += x, x => _data.AttachedToLogicalTree -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DetachedFromLogicalTree => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DetachedFromLogicalTree += x, x => _data.DetachedFromLogicalTree -= x); + } +} + +namespace Avalonia.Markup.Xaml.MarkupExtensions +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxResourceIncludeEvents Events(this global::Avalonia.Markup.Xaml.MarkupExtensions.ResourceInclude item) => new RxResourceIncludeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxResourceIncludeEvents + { + private readonly global::Avalonia.Markup.Xaml.MarkupExtensions.ResourceInclude _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxResourceIncludeEvents(global::Avalonia.Markup.Xaml.MarkupExtensions.ResourceInclude data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResourcesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.ResourcesChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + } +} + +namespace Avalonia.Markup.Xaml.Styling +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStyleIncludeEvents Events(this global::Avalonia.Markup.Xaml.Styling.StyleInclude item) => new RxStyleIncludeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStyleIncludeEvents + { + private readonly global::Avalonia.Markup.Xaml.Styling.StyleInclude _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStyleIncludeEvents(global::Avalonia.Markup.Xaml.Styling.StyleInclude data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResourcesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.ResourcesChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + } +} + +namespace Avalonia.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBrushEvents Events(this global::Avalonia.Media.Brush item) => new RxBrushEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDashStyleEvents Events(this global::Avalonia.Media.DashStyle item) => new RxDashStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGeometryEvents Events(this global::Avalonia.Media.Geometry item) => new RxGeometryEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIAffectsRenderEvents Events(this global::Avalonia.Media.IAffectsRender item) => new RxIAffectsRenderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPenEvents Events(this global::Avalonia.Media.Pen item) => new RxPenEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTransformEvents Events(this global::Avalonia.Media.Transform item) => new RxTransformEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBrushEvents : global::Avalonia.RxAvaloniaObjectEvents + { + private readonly global::Avalonia.Media.Brush _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBrushEvents(global::Avalonia.Media.Brush data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDashStyleEvents : global::Avalonia.RxAvaloniaObjectEvents + { + private readonly global::Avalonia.Media.DashStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDashStyleEvents(global::Avalonia.Media.DashStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGeometryEvents : global::Avalonia.RxAvaloniaObjectEvents + { + private readonly global::Avalonia.Media.Geometry _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGeometryEvents(global::Avalonia.Media.Geometry data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIAffectsRenderEvents + { + private readonly global::Avalonia.Media.IAffectsRender _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIAffectsRenderEvents(global::Avalonia.Media.IAffectsRender data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPenEvents : global::Avalonia.RxAvaloniaObjectEvents + { + private readonly global::Avalonia.Media.Pen _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPenEvents(global::Avalonia.Media.Pen data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTransformEvents : global::Avalonia.RxAvaloniaObjectEvents + { + private readonly global::Avalonia.Media.Transform _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTransformEvents(global::Avalonia.Media.Transform data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace Avalonia.Platform +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIEmbeddableWindowImplEvents Events(this global::Avalonia.Platform.IEmbeddableWindowImpl item) => new RxIEmbeddableWindowImplEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPlatformThreadingInterfaceEvents Events(this global::Avalonia.Platform.IPlatformThreadingInterface item) => new RxIPlatformThreadingInterfaceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIEmbeddableWindowImplEvents + { + private readonly global::Avalonia.Platform.IEmbeddableWindowImpl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIEmbeddableWindowImplEvents(global::Avalonia.Platform.IEmbeddableWindowImpl data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler() => eventHandler(global::System.Reactive.Unit.Default); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPlatformThreadingInterfaceEvents + { + private readonly global::Avalonia.Platform.IPlatformThreadingInterface _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPlatformThreadingInterfaceEvents(global::Avalonia.Platform.IPlatformThreadingInterface data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> Signaled => global::System.Reactive.Linq.Observable.FromEvent>, global::System.Nullable>(eventHandler => + { + void Handler(global::System.Nullable obj) => eventHandler(obj); + return Handler; + }, x => _data.Signaled += x, x => _data.Signaled -= x); + } +} + +namespace Avalonia.Rendering +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDefaultRenderTimerEvents Events(this global::Avalonia.Rendering.DefaultRenderTimer item) => new RxDefaultRenderTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDeferredRendererEvents Events(this global::Avalonia.Rendering.DeferredRenderer item) => new RxDeferredRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImmediateRendererEvents Events(this global::Avalonia.Rendering.ImmediateRenderer item) => new RxImmediateRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIRendererEvents Events(this global::Avalonia.Rendering.IRenderer item) => new RxIRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIRenderTimerEvents Events(this global::Avalonia.Rendering.IRenderTimer item) => new RxIRenderTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDefaultRenderTimerEvents + { + private readonly global::Avalonia.Rendering.DefaultRenderTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDefaultRenderTimerEvents(global::Avalonia.Rendering.DefaultRenderTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent, global::System.TimeSpan>(eventHandler => + { + void Handler(global::System.TimeSpan obj) => eventHandler(obj); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDeferredRendererEvents + { + private readonly global::Avalonia.Rendering.DeferredRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDeferredRendererEvents(global::Avalonia.Rendering.DeferredRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SceneInvalidated => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Rendering.SceneInvalidatedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Rendering.SceneInvalidatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImmediateRendererEvents + { + private readonly global::Avalonia.Rendering.ImmediateRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImmediateRendererEvents(global::Avalonia.Rendering.ImmediateRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SceneInvalidated => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Rendering.SceneInvalidatedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Rendering.SceneInvalidatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIRendererEvents + { + private readonly global::Avalonia.Rendering.IRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIRendererEvents(global::Avalonia.Rendering.IRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SceneInvalidated => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Rendering.SceneInvalidatedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Rendering.SceneInvalidatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIRenderTimerEvents + { + private readonly global::Avalonia.Rendering.IRenderTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIRenderTimerEvents(global::Avalonia.Rendering.IRenderTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent, global::System.TimeSpan>(eventHandler => + { + void Handler(global::System.TimeSpan obj) => eventHandler(obj); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace Avalonia.Styling +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStyleEvents Events(this global::Avalonia.Styling.Style item) => new RxStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylesEvents Events(this global::Avalonia.Styling.Styles item) => new RxStylesEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStyleEvents : global::Avalonia.RxAvaloniaObjectEvents + { + private readonly global::Avalonia.Styling.Style _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStyleEvents(global::Avalonia.Styling.Style data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResourcesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.ResourcesChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylesEvents : global::Avalonia.RxAvaloniaObjectEvents + { + private readonly global::Avalonia.Styling.Styles _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylesEvents(global::Avalonia.Styling.Styles data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResourcesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.Controls.ResourcesChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + } +} + +namespace Avalonia.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::Avalonia.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::Avalonia.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::Avalonia.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace Avalonia.VisualTree +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIVisualEvents Events(this global::Avalonia.VisualTree.IVisual item) => new RxIVisualEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIVisualEvents + { + private readonly global::Avalonia.VisualTree.IVisual _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIVisualEvents(global::Avalonia.VisualTree.IVisual data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttachedToVisualTree => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.VisualTreeAttachmentEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttachedToVisualTree += x, x => _data.AttachedToVisualTree -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DetachedFromVisualTree => global::System.Reactive.Linq.Observable.FromEvent, global::Avalonia.VisualTreeAttachmentEventArgs>(eventHandler => + { + void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DetachedFromVisualTree += x, x => _data.DetachedFromVisualTree -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.netstandard2.0.approved.txt index 8427975..d31db4c 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.netstandard2.0.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.0.9.12.netstandard2.0.approved.txt @@ -1,3 +1,4 @@ + using global::System; using global::System.Reactive; using global::System.Reactive.Linq; @@ -59,9 +60,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } /// @@ -86,9 +85,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.AvaloniaPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -113,9 +110,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.AvaloniaPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InheritablePropertyChanged += x, x => _data.InheritablePropertyChanged -= x); + }, x => _data.InheritablePropertyChanged += x, x => _data.InheritablePropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -123,9 +118,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.AvaloniaPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -150,9 +143,7 @@ namespace Avalonia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Initialized += x, x => _data.Initialized -= x); + }, x => _data.Initialized += x, x => _data.Initialized -= x); } /// @@ -177,9 +168,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AttachedToLogicalTree += x, x => _data.AttachedToLogicalTree -= x); + }, x => _data.AttachedToLogicalTree += x, x => _data.AttachedToLogicalTree -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -187,9 +176,7 @@ namespace Avalonia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -197,9 +184,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DetachedFromLogicalTree += x, x => _data.DetachedFromLogicalTree -= x); + }, x => _data.DetachedFromLogicalTree += x, x => _data.DetachedFromLogicalTree -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -207,9 +192,7 @@ namespace Avalonia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Initialized += x, x => _data.Initialized -= x); + }, x => _data.Initialized += x, x => _data.Initialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -217,9 +200,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } /// @@ -244,9 +225,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AttachedToVisualTree += x, x => _data.AttachedToVisualTree -= x); + }, x => _data.AttachedToVisualTree += x, x => _data.AttachedToVisualTree -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -254,9 +233,7 @@ namespace Avalonia { void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DetachedFromVisualTree += x, x => _data.DetachedFromVisualTree -= x); + }, x => _data.DetachedFromVisualTree += x, x => _data.DetachedFromVisualTree -= x); } } @@ -295,9 +272,7 @@ namespace Avalonia.Collections { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -305,9 +280,7 @@ namespace Avalonia.Collections { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } } @@ -414,9 +387,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -424,9 +395,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownClosing += x, x => _data.DropDownClosing -= x); + }, x => _data.DropDownClosing += x, x => _data.DropDownClosing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -434,9 +403,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -444,9 +411,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -454,9 +419,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.PopulatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Populated += x, x => _data.Populated -= x); + }, x => _data.Populated += x, x => _data.Populated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -464,9 +427,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.PopulatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Populating += x, x => _data.Populating -= x); + }, x => _data.Populating += x, x => _data.Populating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -474,9 +435,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -484,9 +443,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -511,9 +468,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -538,9 +493,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -548,9 +501,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -558,9 +509,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); } /// @@ -585,9 +534,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -595,9 +542,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); } /// @@ -622,9 +567,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -632,9 +575,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -642,9 +583,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -652,9 +591,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); } /// @@ -679,9 +616,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } /// @@ -706,9 +641,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.ItemsRepeaterElementClearingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementClearing += x, x => _data.ElementClearing -= x); + }, x => _data.ElementClearing += x, x => _data.ElementClearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -716,9 +649,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.ItemsRepeaterElementIndexChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementIndexChanged += x, x => _data.ElementIndexChanged -= x); + }, x => _data.ElementIndexChanged += x, x => _data.ElementIndexChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -726,9 +657,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.ItemsRepeaterElementPreparedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPrepared += x, x => _data.ElementPrepared -= x); + }, x => _data.ElementPrepared += x, x => _data.ElementPrepared -= x); } /// @@ -753,9 +682,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -780,9 +707,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MenuClosed += x, x => _data.MenuClosed -= x); + }, x => _data.MenuClosed += x, x => _data.MenuClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -790,9 +715,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MenuOpened += x, x => _data.MenuOpened -= x); + }, x => _data.MenuOpened += x, x => _data.MenuOpened -= x); } /// @@ -817,9 +740,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -827,9 +748,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerEnterItem += x, x => _data.PointerEnterItem -= x); + }, x => _data.PointerEnterItem += x, x => _data.PointerEnterItem -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -837,9 +756,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerLeaveItem += x, x => _data.PointerLeaveItem -= x); + }, x => _data.PointerLeaveItem += x, x => _data.PointerLeaveItem -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -847,9 +764,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); } /// @@ -874,9 +789,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -901,9 +814,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SpinEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Spinned += x, x => _data.Spinned -= x); + }, x => _data.Spinned += x, x => _data.Spinned -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -911,9 +822,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.NumericUpDownValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -938,9 +847,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } /// @@ -965,9 +872,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SpinEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Spin += x, x => _data.Spin -= x); + }, x => _data.Spin += x, x => _data.Spin -= x); } /// @@ -992,9 +897,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1002,9 +905,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -1029,9 +930,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -1056,9 +955,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); } /// @@ -1083,9 +980,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1093,9 +988,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Deactivated += x, x => _data.Deactivated -= x); + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1103,9 +996,7 @@ namespace Avalonia.Controls { void Handler(object sender, global::Avalonia.Controls.PixelPointEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } } @@ -1148,9 +1039,7 @@ namespace Avalonia.Controls.ApplicationLifetimes { void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeExitEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Exit += x, x => _data.Exit -= x); + }, x => _data.Exit += x, x => _data.Exit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1158,9 +1047,7 @@ namespace Avalonia.Controls.ApplicationLifetimes { void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeStartupEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Startup += x, x => _data.Startup -= x); + }, x => _data.Startup += x, x => _data.Startup -= x); } /// @@ -1185,9 +1072,7 @@ namespace Avalonia.Controls.ApplicationLifetimes { void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeExitEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Exit += x, x => _data.Exit -= x); + }, x => _data.Exit += x, x => _data.Exit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1195,9 +1080,7 @@ namespace Avalonia.Controls.ApplicationLifetimes { void Handler(object sender, global::Avalonia.Controls.ApplicationLifetimes.ControlledApplicationLifetimeStartupEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Startup += x, x => _data.Startup -= x); + }, x => _data.Startup += x, x => _data.Startup -= x); } } @@ -1244,9 +1127,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dematerialized += x, x => _data.Dematerialized -= x); + }, x => _data.Dematerialized += x, x => _data.Dematerialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1254,9 +1135,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Materialized += x, x => _data.Materialized -= x); + }, x => _data.Materialized += x, x => _data.Materialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1264,9 +1143,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Recycled += x, x => _data.Recycled -= x); + }, x => _data.Recycled += x, x => _data.Recycled -= x); } /// @@ -1291,9 +1168,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dematerialized += x, x => _data.Dematerialized -= x); + }, x => _data.Dematerialized += x, x => _data.Dematerialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1301,9 +1176,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Materialized += x, x => _data.Materialized -= x); + }, x => _data.Materialized += x, x => _data.Materialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1311,9 +1184,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Recycled += x, x => _data.Recycled -= x); + }, x => _data.Recycled += x, x => _data.Recycled -= x); } /// @@ -1338,9 +1209,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dematerialized += x, x => _data.Dematerialized -= x); + }, x => _data.Dematerialized += x, x => _data.Dematerialized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1348,9 +1217,7 @@ namespace Avalonia.Controls.Generators { void Handler(object sender, global::Avalonia.Controls.Generators.ItemContainerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Materialized += x, x => _data.Materialized -= x); + }, x => _data.Materialized += x, x => _data.Materialized -= x); } } @@ -1389,9 +1256,7 @@ namespace Avalonia.Controls.Notifications { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NotificationClosed += x, x => _data.NotificationClosed -= x); + }, x => _data.NotificationClosed += x, x => _data.NotificationClosed -= x); } } @@ -1434,9 +1299,7 @@ namespace Avalonia.Controls.Platform { void Handler(global::System.Nullable obj) => eventHandler(obj); return Handler; - } - - , x => _data.Signaled += x, x => _data.Signaled -= x); + }, x => _data.Signaled += x, x => _data.Signaled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1444,9 +1307,7 @@ namespace Avalonia.Controls.Platform { void Handler(global::System.TimeSpan obj) => eventHandler(obj); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// @@ -1471,9 +1332,7 @@ namespace Avalonia.Controls.Platform { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnIsNativeMenuExportedChanged += x, x => _data.OnIsNativeMenuExportedChanged -= x); + }, x => _data.OnIsNativeMenuExportedChanged += x, x => _data.OnIsNativeMenuExportedChanged -= x); } } @@ -1544,9 +1403,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarLeftMouseButtonDown += x, x => _data.CalendarLeftMouseButtonDown -= x); + }, x => _data.CalendarLeftMouseButtonDown += x, x => _data.CalendarLeftMouseButtonDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1554,9 +1411,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarLeftMouseButtonUp += x, x => _data.CalendarLeftMouseButtonUp -= x); + }, x => _data.CalendarLeftMouseButtonUp += x, x => _data.CalendarLeftMouseButtonUp -= x); } /// @@ -1581,9 +1436,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarDayButtonMouseDown += x, x => _data.CalendarDayButtonMouseDown -= x); + }, x => _data.CalendarDayButtonMouseDown += x, x => _data.CalendarDayButtonMouseDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1591,9 +1444,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CalendarDayButtonMouseUp += x, x => _data.CalendarDayButtonMouseUp -= x); + }, x => _data.CalendarDayButtonMouseUp += x, x => _data.CalendarDayButtonMouseUp -= x); } /// @@ -1618,9 +1469,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Controls.Primitives.TemplateAppliedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TemplateApplied += x, x => _data.TemplateApplied -= x); + }, x => _data.TemplateApplied += x, x => _data.TemplateApplied -= x); } /// @@ -1645,9 +1494,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1655,9 +1502,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -1682,9 +1527,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scroll += x, x => _data.Scroll -= x); + }, x => _data.Scroll += x, x => _data.Scroll -= x); } /// @@ -1709,9 +1552,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -1736,9 +1577,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Controls.Primitives.TemplateAppliedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TemplateApplied += x, x => _data.TemplateApplied -= x); + }, x => _data.TemplateApplied += x, x => _data.TemplateApplied -= x); } /// @@ -1763,9 +1602,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.VectorEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1773,9 +1610,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.VectorEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragDelta += x, x => _data.DragDelta -= x); + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1783,9 +1618,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Input.VectorEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); } /// @@ -1810,9 +1643,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Checked += x, x => _data.Checked -= x); + }, x => _data.Checked += x, x => _data.Checked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1820,9 +1651,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1830,9 +1659,7 @@ namespace Avalonia.Controls.Primitives { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unchecked += x, x => _data.Unchecked -= x); + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); } } @@ -1875,9 +1702,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Cancel += x, x => _data.Cancel -= x); + }, x => _data.Cancel += x, x => _data.Cancel -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1885,9 +1710,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Commit += x, x => _data.Commit -= x); + }, x => _data.Commit += x, x => _data.Commit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1895,9 +1718,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -1922,9 +1743,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Cancel += x, x => _data.Cancel -= x); + }, x => _data.Cancel += x, x => _data.Cancel -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1932,9 +1751,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Commit += x, x => _data.Commit -= x); + }, x => _data.Commit += x, x => _data.Commit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1942,9 +1759,7 @@ namespace Avalonia.Controls.Utils { void Handler(object sender, global::Avalonia.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } } @@ -1999,9 +1814,7 @@ namespace Avalonia.Input { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } /// @@ -2026,9 +1839,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.GotFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2036,9 +1847,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2046,9 +1855,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2056,9 +1863,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2066,9 +1871,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerEnter += x, x => _data.PointerEnter -= x); + }, x => _data.PointerEnter += x, x => _data.PointerEnter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2076,9 +1879,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerLeave += x, x => _data.PointerLeave -= x); + }, x => _data.PointerLeave += x, x => _data.PointerLeave -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2086,9 +1887,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2096,9 +1895,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2106,9 +1903,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2116,9 +1911,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerWheelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2126,9 +1919,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.TextInputEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextInput += x, x => _data.TextInput -= x); + }, x => _data.TextInput += x, x => _data.TextInput -= x); } /// @@ -2153,9 +1944,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MenuClosed += x, x => _data.MenuClosed -= x); + }, x => _data.MenuClosed += x, x => _data.MenuClosed -= x); } /// @@ -2180,9 +1969,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); + }, x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2190,9 +1977,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.GotFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2200,9 +1985,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2210,9 +1993,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2220,9 +2001,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2230,9 +2009,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerCaptureLostEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2240,9 +2017,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerEnter += x, x => _data.PointerEnter -= x); + }, x => _data.PointerEnter += x, x => _data.PointerEnter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2250,9 +2025,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerLeave += x, x => _data.PointerLeave -= x); + }, x => _data.PointerLeave += x, x => _data.PointerLeave -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2260,9 +2033,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2270,9 +2041,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2280,9 +2049,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerReleasedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2290,9 +2057,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.PointerWheelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2300,9 +2065,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Interactivity.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2310,9 +2073,7 @@ namespace Avalonia.Input { void Handler(object sender, global::Avalonia.Input.TextInputEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextInput += x, x => _data.TextInput -= x); + }, x => _data.TextInput += x, x => _data.TextInput -= x); } /// @@ -2337,9 +2098,7 @@ namespace Avalonia.Input { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } } @@ -2382,9 +2141,7 @@ namespace Avalonia.Layout { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ArrangeInvalidated += x, x => _data.ArrangeInvalidated -= x); + }, x => _data.ArrangeInvalidated += x, x => _data.ArrangeInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2392,9 +2149,7 @@ namespace Avalonia.Layout { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); } /// @@ -2419,9 +2174,7 @@ namespace Avalonia.Layout { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); } } @@ -2460,9 +2213,7 @@ namespace Avalonia.LogicalTree { void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AttachedToLogicalTree += x, x => _data.AttachedToLogicalTree -= x); + }, x => _data.AttachedToLogicalTree += x, x => _data.AttachedToLogicalTree -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2470,9 +2221,7 @@ namespace Avalonia.LogicalTree { void Handler(object sender, global::Avalonia.LogicalTree.LogicalTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DetachedFromLogicalTree += x, x => _data.DetachedFromLogicalTree -= x); + }, x => _data.DetachedFromLogicalTree += x, x => _data.DetachedFromLogicalTree -= x); } } @@ -2511,9 +2260,7 @@ namespace Avalonia.Markup.Xaml.MarkupExtensions { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } } @@ -2552,9 +2299,7 @@ namespace Avalonia.Markup.Xaml.Styling { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } } @@ -2613,9 +2358,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invalidated += x, x => _data.Invalidated -= x); + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); } /// @@ -2640,9 +2383,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invalidated += x, x => _data.Invalidated -= x); + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); } /// @@ -2667,9 +2408,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } /// @@ -2694,9 +2433,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invalidated += x, x => _data.Invalidated -= x); + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); } /// @@ -2721,9 +2458,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invalidated += x, x => _data.Invalidated -= x); + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); } /// @@ -2748,9 +2483,7 @@ namespace Avalonia.Media { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } } @@ -2793,9 +2526,7 @@ namespace Avalonia.Platform { void Handler() => eventHandler(global::System.Reactive.Unit.Default); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); } /// @@ -2820,9 +2551,7 @@ namespace Avalonia.Platform { void Handler(global::System.Nullable obj) => eventHandler(obj); return Handler; - } - - , x => _data.Signaled += x, x => _data.Signaled -= x); + }, x => _data.Signaled += x, x => _data.Signaled -= x); } } @@ -2877,9 +2606,7 @@ namespace Avalonia.Rendering { void Handler(global::System.TimeSpan obj) => eventHandler(obj); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// @@ -2904,9 +2631,7 @@ namespace Avalonia.Rendering { void Handler(object sender, global::Avalonia.Rendering.SceneInvalidatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); + }, x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); } /// @@ -2931,9 +2656,7 @@ namespace Avalonia.Rendering { void Handler(object sender, global::Avalonia.Rendering.SceneInvalidatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); + }, x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); } /// @@ -2958,9 +2681,7 @@ namespace Avalonia.Rendering { void Handler(object sender, global::Avalonia.Rendering.SceneInvalidatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); + }, x => _data.SceneInvalidated += x, x => _data.SceneInvalidated -= x); } /// @@ -2985,9 +2706,7 @@ namespace Avalonia.Rendering { void Handler(global::System.TimeSpan obj) => eventHandler(obj); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } } @@ -3030,9 +2749,7 @@ namespace Avalonia.Styling { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } /// @@ -3057,9 +2774,7 @@ namespace Avalonia.Styling { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3067,9 +2782,7 @@ namespace Avalonia.Styling { void Handler(object sender, global::Avalonia.Controls.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); + }, x => _data.ResourcesChanged += x, x => _data.ResourcesChanged -= x); } } @@ -3108,9 +2821,7 @@ namespace Avalonia.Threading { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } } @@ -3149,9 +2860,7 @@ namespace Avalonia.VisualTree { void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AttachedToVisualTree += x, x => _data.AttachedToVisualTree -= x); + }, x => _data.AttachedToVisualTree += x, x => _data.AttachedToVisualTree -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3159,8 +2868,6 @@ namespace Avalonia.VisualTree { void Handler(object sender, global::Avalonia.VisualTreeAttachmentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DetachedFromVisualTree += x, x => _data.DetachedFromVisualTree -= x); + }, x => _data.DetachedFromVisualTree += x, x => _data.DetachedFromVisualTree -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.Remote.Protocol.0.9.12.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.Remote.Protocol.0.9.12.netstandard2.0.approved.txt index 417ea07..764d7fa 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.Remote.Protocol.0.9.12.netstandard2.0.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Avalonia.Remote.Protocol.0.9.12.netstandard2.0.approved.txt @@ -1,3 +1,4 @@ + using global::System; using global::System.Reactive; using global::System.Reactive.Linq; @@ -43,9 +44,7 @@ namespace Avalonia.Remote.Protocol { void Handler(global::Avalonia.Remote.Protocol.IAvaloniaRemoteTransportConnection arg1, global::System.Exception arg2) => eventHandler((arg1, arg2)); return Handler; - } - - , x => _data.OnException += x, x => _data.OnException -= x); + }, x => _data.OnException += x, x => _data.OnException -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -53,9 +52,7 @@ namespace Avalonia.Remote.Protocol { void Handler(global::Avalonia.Remote.Protocol.IAvaloniaRemoteTransportConnection arg1, object arg2) => eventHandler((arg1, arg2)); return Handler; - } - - , x => _data.OnMessage += x, x => _data.OnMessage -= x); + }, x => _data.OnMessage += x, x => _data.OnMessage -= x); } /// @@ -80,9 +77,7 @@ namespace Avalonia.Remote.Protocol { void Handler(global::Avalonia.Remote.Protocol.IAvaloniaRemoteTransportConnection arg1, global::System.Exception arg2) => eventHandler((arg1, arg2)); return Handler; - } - - , x => _data.OnException += x, x => _data.OnException -= x); + }, x => _data.OnException += x, x => _data.OnException -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -90,8 +85,6 @@ namespace Avalonia.Remote.Protocol { void Handler(global::Avalonia.Remote.Protocol.IAvaloniaRemoteTransportConnection arg1, object arg2) => eventHandler((arg1, arg2)); return Handler; - } - - , x => _data.OnMessage += x, x => _data.OnMessage -= x); + }, x => _data.OnMessage += x, x => _data.OnMessage -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net461.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net461.winforms.approved.txt new file mode 100644 index 0000000..0405401 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net461.winforms.approved.txt @@ -0,0 +1,10544 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolboxItemEvents Events(this global::System.Drawing.Design.ToolboxItem item) => new RxToolboxItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolboxItemEvents + { + private readonly global::System.Drawing.Design.ToolboxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolboxItemEvents(global::System.Drawing.Design.ToolboxItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreated += x, x => _data.ComponentsCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreating += x, x => _data.ComponentsCreating -= x); + } +} + +namespace System.Drawing.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintDocumentEvents Events(this global::System.Drawing.Printing.PrintDocument item) => new RxPrintDocumentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintDocumentEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Drawing.Printing.PrintDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintDocumentEvents(global::System.Drawing.Printing.PrintDocument data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginPrint += x, x => _data.BeginPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndPrint += x, x => _data.EndPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PrintPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintPageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PrintPage += x, x => _data.PrintPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryPageSettings => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.QueryPageSettingsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryPageSettings += x, x => _data.QueryPageSettings -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Forms.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Forms.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridBoolColumnEvents Events(this global::System.Windows.Forms.DataGridBoolColumn item) => new RxDataGridBoolColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnStyleEvents Events(this global::System.Windows.Forms.DataGridColumnStyle item) => new RxDataGridColumnStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridTableStyleEvents Events(this global::System.Windows.Forms.DataGridTableStyle item) => new RxDataGridTableStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridColumnStylesCollectionEvents Events(this global::System.Windows.Forms.GridColumnStylesCollection item) => new RxGridColumnStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridTableStylesCollectionEvents Events(this global::System.Windows.Forms.GridTableStylesCollection item) => new RxGridTableStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMainMenuEvents Events(this global::System.Windows.Forms.MainMenu item) => new RxMainMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Forms.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::System.Windows.Forms.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolBarEvents Events(this global::System.Windows.Forms.ToolBar item) => new RxToolBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Forms.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Forms.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNavigationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNavigationChanged += x, x => _data.AllowNavigationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackButtonClick += x, x => _data.BackButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CaptionVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CaptionVisibleChanged += x, x => _data.CaptionVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FlatModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FlatModeChanged += x, x => _data.FlatModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NavigateEventArgs ne) => eventHandler(ne); + return Handler; + }, x => _data.Navigate += x, x => _data.Navigate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsLabelStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsLabelStyleChanged += x, x => _data.ParentRowsLabelStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsVisibleChanged += x, x => _data.ParentRowsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShowParentDetailsButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShowParentDetailsButtonClick += x, x => _data.ShowParentDetailsButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridBoolColumnEvents : global::System.Windows.Forms.RxDataGridColumnStyleEvents + { + private readonly global::System.Windows.Forms.DataGridBoolColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridBoolColumnEvents(global::System.Windows.Forms.DataGridBoolColumn data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNullChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNullChanged += x, x => _data.AllowNullChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FalseValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FalseValueChanged += x, x => _data.FalseValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TrueValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TrueValueChanged += x, x => _data.TrueValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridColumnStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnStyleEvents(global::System.Windows.Forms.DataGridColumnStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlignmentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlignmentChanged += x, x => _data.AlignmentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderTextChanged += x, x => _data.HeaderTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NullTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NullTextChanged += x, x => _data.NullTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDescriptorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDescriptorChanged += x, x => _data.PropertyDescriptorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WidthChanged += x, x => _data.WidthChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridTableStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridTableStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridTableStyleEvents(global::System.Windows.Forms.DataGridTableStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowSortingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowSortingChanged += x, x => _data.AllowSortingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingBackColorChanged += x, x => _data.AlternatingBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersVisibleChanged += x, x => _data.ColumnHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineColorChanged += x, x => _data.GridLineColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineStyleChanged += x, x => _data.GridLineStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderBackColorChanged += x, x => _data.HeaderBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderFontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderFontChanged += x, x => _data.HeaderFontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderForeColorChanged += x, x => _data.HeaderForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkColorChanged += x, x => _data.LinkColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkHoverColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkHoverColorChanged += x, x => _data.LinkHoverColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredColumnWidthChanged += x, x => _data.PreferredColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredRowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredRowHeightChanged += x, x => _data.PreferredRowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersVisibleChanged += x, x => _data.RowHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderWidthChanged += x, x => _data.RowHeaderWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionBackColorChanged += x, x => _data.SelectionBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionForeColorChanged += x, x => _data.SelectionForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridColumnStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridColumnStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridColumnStylesCollectionEvents(global::System.Windows.Forms.GridColumnStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridTableStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridTableStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridTableStylesCollectionEvents(global::System.Windows.Forms.GridTableStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMainMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MainMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMainMenuEvents(global::System.Windows.Forms.MainMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Forms.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Select => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Select += x, x => _data.Select -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::System.Windows.Forms.StatusBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarDrawItemEventArgs sbdevent) => eventHandler(sbdevent); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PanelClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarPanelClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PanelClick += x, x => _data.PanelClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ToolBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolBarEvents(global::System.Windows.Forms.ToolBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDropDown += x, x => _data.ButtonDropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net461.wpf.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net461.wpf.approved.txt new file mode 100644 index 0000000..aa87afa --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net461.wpf.approved.txt @@ -0,0 +1,7127 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net461.wpf.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net461.wpf.winforms.approved.txt new file mode 100644 index 0000000..fda6262 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net461.wpf.winforms.approved.txt @@ -0,0 +1,17655 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolboxItemEvents Events(this global::System.Drawing.Design.ToolboxItem item) => new RxToolboxItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolboxItemEvents + { + private readonly global::System.Drawing.Design.ToolboxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolboxItemEvents(global::System.Drawing.Design.ToolboxItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreated += x, x => _data.ComponentsCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreating += x, x => _data.ComponentsCreating -= x); + } +} + +namespace System.Drawing.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintDocumentEvents Events(this global::System.Drawing.Printing.PrintDocument item) => new RxPrintDocumentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintDocumentEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Drawing.Printing.PrintDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintDocumentEvents(global::System.Drawing.Printing.PrintDocument data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginPrint += x, x => _data.BeginPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndPrint += x, x => _data.EndPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PrintPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintPageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PrintPage += x, x => _data.PrintPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryPageSettings => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.QueryPageSettingsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryPageSettings += x, x => _data.QueryPageSettings -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Forms.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Forms.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridBoolColumnEvents Events(this global::System.Windows.Forms.DataGridBoolColumn item) => new RxDataGridBoolColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnStyleEvents Events(this global::System.Windows.Forms.DataGridColumnStyle item) => new RxDataGridColumnStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridTableStyleEvents Events(this global::System.Windows.Forms.DataGridTableStyle item) => new RxDataGridTableStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridColumnStylesCollectionEvents Events(this global::System.Windows.Forms.GridColumnStylesCollection item) => new RxGridColumnStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridTableStylesCollectionEvents Events(this global::System.Windows.Forms.GridTableStylesCollection item) => new RxGridTableStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMainMenuEvents Events(this global::System.Windows.Forms.MainMenu item) => new RxMainMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Forms.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::System.Windows.Forms.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolBarEvents Events(this global::System.Windows.Forms.ToolBar item) => new RxToolBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Forms.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Forms.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNavigationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNavigationChanged += x, x => _data.AllowNavigationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackButtonClick += x, x => _data.BackButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CaptionVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CaptionVisibleChanged += x, x => _data.CaptionVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FlatModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FlatModeChanged += x, x => _data.FlatModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NavigateEventArgs ne) => eventHandler(ne); + return Handler; + }, x => _data.Navigate += x, x => _data.Navigate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsLabelStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsLabelStyleChanged += x, x => _data.ParentRowsLabelStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsVisibleChanged += x, x => _data.ParentRowsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShowParentDetailsButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShowParentDetailsButtonClick += x, x => _data.ShowParentDetailsButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridBoolColumnEvents : global::System.Windows.Forms.RxDataGridColumnStyleEvents + { + private readonly global::System.Windows.Forms.DataGridBoolColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridBoolColumnEvents(global::System.Windows.Forms.DataGridBoolColumn data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNullChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNullChanged += x, x => _data.AllowNullChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FalseValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FalseValueChanged += x, x => _data.FalseValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TrueValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TrueValueChanged += x, x => _data.TrueValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridColumnStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnStyleEvents(global::System.Windows.Forms.DataGridColumnStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlignmentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlignmentChanged += x, x => _data.AlignmentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderTextChanged += x, x => _data.HeaderTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NullTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NullTextChanged += x, x => _data.NullTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDescriptorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDescriptorChanged += x, x => _data.PropertyDescriptorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WidthChanged += x, x => _data.WidthChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridTableStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridTableStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridTableStyleEvents(global::System.Windows.Forms.DataGridTableStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowSortingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowSortingChanged += x, x => _data.AllowSortingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingBackColorChanged += x, x => _data.AlternatingBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersVisibleChanged += x, x => _data.ColumnHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineColorChanged += x, x => _data.GridLineColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineStyleChanged += x, x => _data.GridLineStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderBackColorChanged += x, x => _data.HeaderBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderFontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderFontChanged += x, x => _data.HeaderFontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderForeColorChanged += x, x => _data.HeaderForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkColorChanged += x, x => _data.LinkColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkHoverColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkHoverColorChanged += x, x => _data.LinkHoverColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredColumnWidthChanged += x, x => _data.PreferredColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredRowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredRowHeightChanged += x, x => _data.PreferredRowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersVisibleChanged += x, x => _data.RowHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderWidthChanged += x, x => _data.RowHeaderWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionBackColorChanged += x, x => _data.SelectionBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionForeColorChanged += x, x => _data.SelectionForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridColumnStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridColumnStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridColumnStylesCollectionEvents(global::System.Windows.Forms.GridColumnStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridTableStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridTableStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridTableStylesCollectionEvents(global::System.Windows.Forms.GridTableStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMainMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MainMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMainMenuEvents(global::System.Windows.Forms.MainMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Forms.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Select => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Select += x, x => _data.Select -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::System.Windows.Forms.StatusBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarDrawItemEventArgs sbdevent) => eventHandler(sbdevent); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PanelClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarPanelClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PanelClick += x, x => _data.PanelClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ToolBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolBarEvents(global::System.Windows.Forms.ToolBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDropDown += x, x => _data.ButtonDropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net462.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net462.winforms.approved.txt new file mode 100644 index 0000000..0405401 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net462.winforms.approved.txt @@ -0,0 +1,10544 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolboxItemEvents Events(this global::System.Drawing.Design.ToolboxItem item) => new RxToolboxItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolboxItemEvents + { + private readonly global::System.Drawing.Design.ToolboxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolboxItemEvents(global::System.Drawing.Design.ToolboxItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreated += x, x => _data.ComponentsCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreating += x, x => _data.ComponentsCreating -= x); + } +} + +namespace System.Drawing.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintDocumentEvents Events(this global::System.Drawing.Printing.PrintDocument item) => new RxPrintDocumentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintDocumentEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Drawing.Printing.PrintDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintDocumentEvents(global::System.Drawing.Printing.PrintDocument data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginPrint += x, x => _data.BeginPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndPrint += x, x => _data.EndPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PrintPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintPageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PrintPage += x, x => _data.PrintPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryPageSettings => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.QueryPageSettingsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryPageSettings += x, x => _data.QueryPageSettings -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Forms.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Forms.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridBoolColumnEvents Events(this global::System.Windows.Forms.DataGridBoolColumn item) => new RxDataGridBoolColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnStyleEvents Events(this global::System.Windows.Forms.DataGridColumnStyle item) => new RxDataGridColumnStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridTableStyleEvents Events(this global::System.Windows.Forms.DataGridTableStyle item) => new RxDataGridTableStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridColumnStylesCollectionEvents Events(this global::System.Windows.Forms.GridColumnStylesCollection item) => new RxGridColumnStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridTableStylesCollectionEvents Events(this global::System.Windows.Forms.GridTableStylesCollection item) => new RxGridTableStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMainMenuEvents Events(this global::System.Windows.Forms.MainMenu item) => new RxMainMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Forms.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::System.Windows.Forms.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolBarEvents Events(this global::System.Windows.Forms.ToolBar item) => new RxToolBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Forms.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Forms.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNavigationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNavigationChanged += x, x => _data.AllowNavigationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackButtonClick += x, x => _data.BackButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CaptionVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CaptionVisibleChanged += x, x => _data.CaptionVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FlatModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FlatModeChanged += x, x => _data.FlatModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NavigateEventArgs ne) => eventHandler(ne); + return Handler; + }, x => _data.Navigate += x, x => _data.Navigate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsLabelStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsLabelStyleChanged += x, x => _data.ParentRowsLabelStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsVisibleChanged += x, x => _data.ParentRowsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShowParentDetailsButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShowParentDetailsButtonClick += x, x => _data.ShowParentDetailsButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridBoolColumnEvents : global::System.Windows.Forms.RxDataGridColumnStyleEvents + { + private readonly global::System.Windows.Forms.DataGridBoolColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridBoolColumnEvents(global::System.Windows.Forms.DataGridBoolColumn data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNullChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNullChanged += x, x => _data.AllowNullChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FalseValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FalseValueChanged += x, x => _data.FalseValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TrueValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TrueValueChanged += x, x => _data.TrueValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridColumnStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnStyleEvents(global::System.Windows.Forms.DataGridColumnStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlignmentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlignmentChanged += x, x => _data.AlignmentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderTextChanged += x, x => _data.HeaderTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NullTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NullTextChanged += x, x => _data.NullTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDescriptorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDescriptorChanged += x, x => _data.PropertyDescriptorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WidthChanged += x, x => _data.WidthChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridTableStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridTableStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridTableStyleEvents(global::System.Windows.Forms.DataGridTableStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowSortingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowSortingChanged += x, x => _data.AllowSortingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingBackColorChanged += x, x => _data.AlternatingBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersVisibleChanged += x, x => _data.ColumnHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineColorChanged += x, x => _data.GridLineColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineStyleChanged += x, x => _data.GridLineStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderBackColorChanged += x, x => _data.HeaderBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderFontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderFontChanged += x, x => _data.HeaderFontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderForeColorChanged += x, x => _data.HeaderForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkColorChanged += x, x => _data.LinkColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkHoverColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkHoverColorChanged += x, x => _data.LinkHoverColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredColumnWidthChanged += x, x => _data.PreferredColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredRowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredRowHeightChanged += x, x => _data.PreferredRowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersVisibleChanged += x, x => _data.RowHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderWidthChanged += x, x => _data.RowHeaderWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionBackColorChanged += x, x => _data.SelectionBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionForeColorChanged += x, x => _data.SelectionForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridColumnStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridColumnStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridColumnStylesCollectionEvents(global::System.Windows.Forms.GridColumnStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridTableStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridTableStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridTableStylesCollectionEvents(global::System.Windows.Forms.GridTableStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMainMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MainMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMainMenuEvents(global::System.Windows.Forms.MainMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Forms.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Select => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Select += x, x => _data.Select -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::System.Windows.Forms.StatusBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarDrawItemEventArgs sbdevent) => eventHandler(sbdevent); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PanelClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarPanelClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PanelClick += x, x => _data.PanelClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ToolBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolBarEvents(global::System.Windows.Forms.ToolBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDropDown += x, x => _data.ButtonDropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net462.wpf.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net462.wpf.approved.txt new file mode 100644 index 0000000..d57d348 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net462.wpf.approved.txt @@ -0,0 +1,7204 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Interop.RxHwndHostEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndHostEvents Events(this global::System.Windows.Interop.HwndHost item) => new RxHwndHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndHostEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Interop.HwndHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndHostEvents(global::System.Windows.Interop.HwndHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.HwndDpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsGenericResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryUnloaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net462.wpf.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net462.wpf.winforms.approved.txt new file mode 100644 index 0000000..2369d5e --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net462.wpf.winforms.approved.txt @@ -0,0 +1,17732 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolboxItemEvents Events(this global::System.Drawing.Design.ToolboxItem item) => new RxToolboxItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolboxItemEvents + { + private readonly global::System.Drawing.Design.ToolboxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolboxItemEvents(global::System.Drawing.Design.ToolboxItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreated += x, x => _data.ComponentsCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreating += x, x => _data.ComponentsCreating -= x); + } +} + +namespace System.Drawing.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintDocumentEvents Events(this global::System.Drawing.Printing.PrintDocument item) => new RxPrintDocumentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintDocumentEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Drawing.Printing.PrintDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintDocumentEvents(global::System.Drawing.Printing.PrintDocument data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginPrint += x, x => _data.BeginPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndPrint += x, x => _data.EndPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PrintPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintPageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PrintPage += x, x => _data.PrintPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryPageSettings => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.QueryPageSettingsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryPageSettings += x, x => _data.QueryPageSettings -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Interop.RxHwndHostEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Forms.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Forms.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridBoolColumnEvents Events(this global::System.Windows.Forms.DataGridBoolColumn item) => new RxDataGridBoolColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnStyleEvents Events(this global::System.Windows.Forms.DataGridColumnStyle item) => new RxDataGridColumnStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridTableStyleEvents Events(this global::System.Windows.Forms.DataGridTableStyle item) => new RxDataGridTableStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridColumnStylesCollectionEvents Events(this global::System.Windows.Forms.GridColumnStylesCollection item) => new RxGridColumnStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridTableStylesCollectionEvents Events(this global::System.Windows.Forms.GridTableStylesCollection item) => new RxGridTableStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMainMenuEvents Events(this global::System.Windows.Forms.MainMenu item) => new RxMainMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Forms.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::System.Windows.Forms.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolBarEvents Events(this global::System.Windows.Forms.ToolBar item) => new RxToolBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Forms.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Forms.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNavigationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNavigationChanged += x, x => _data.AllowNavigationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackButtonClick += x, x => _data.BackButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CaptionVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CaptionVisibleChanged += x, x => _data.CaptionVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FlatModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FlatModeChanged += x, x => _data.FlatModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NavigateEventArgs ne) => eventHandler(ne); + return Handler; + }, x => _data.Navigate += x, x => _data.Navigate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsLabelStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsLabelStyleChanged += x, x => _data.ParentRowsLabelStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsVisibleChanged += x, x => _data.ParentRowsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShowParentDetailsButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShowParentDetailsButtonClick += x, x => _data.ShowParentDetailsButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridBoolColumnEvents : global::System.Windows.Forms.RxDataGridColumnStyleEvents + { + private readonly global::System.Windows.Forms.DataGridBoolColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridBoolColumnEvents(global::System.Windows.Forms.DataGridBoolColumn data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNullChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNullChanged += x, x => _data.AllowNullChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FalseValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FalseValueChanged += x, x => _data.FalseValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TrueValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TrueValueChanged += x, x => _data.TrueValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridColumnStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnStyleEvents(global::System.Windows.Forms.DataGridColumnStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlignmentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlignmentChanged += x, x => _data.AlignmentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderTextChanged += x, x => _data.HeaderTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NullTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NullTextChanged += x, x => _data.NullTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDescriptorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDescriptorChanged += x, x => _data.PropertyDescriptorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WidthChanged += x, x => _data.WidthChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridTableStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridTableStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridTableStyleEvents(global::System.Windows.Forms.DataGridTableStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowSortingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowSortingChanged += x, x => _data.AllowSortingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingBackColorChanged += x, x => _data.AlternatingBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersVisibleChanged += x, x => _data.ColumnHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineColorChanged += x, x => _data.GridLineColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineStyleChanged += x, x => _data.GridLineStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderBackColorChanged += x, x => _data.HeaderBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderFontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderFontChanged += x, x => _data.HeaderFontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderForeColorChanged += x, x => _data.HeaderForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkColorChanged += x, x => _data.LinkColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkHoverColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkHoverColorChanged += x, x => _data.LinkHoverColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredColumnWidthChanged += x, x => _data.PreferredColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredRowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredRowHeightChanged += x, x => _data.PreferredRowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersVisibleChanged += x, x => _data.RowHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderWidthChanged += x, x => _data.RowHeaderWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionBackColorChanged += x, x => _data.SelectionBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionForeColorChanged += x, x => _data.SelectionForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridColumnStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridColumnStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridColumnStylesCollectionEvents(global::System.Windows.Forms.GridColumnStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridTableStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridTableStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridTableStylesCollectionEvents(global::System.Windows.Forms.GridTableStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMainMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MainMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMainMenuEvents(global::System.Windows.Forms.MainMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Forms.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Select => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Select += x, x => _data.Select -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::System.Windows.Forms.StatusBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarDrawItemEventArgs sbdevent) => eventHandler(sbdevent); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PanelClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarPanelClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PanelClick += x, x => _data.PanelClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ToolBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolBarEvents(global::System.Windows.Forms.ToolBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDropDown += x, x => _data.ButtonDropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndHostEvents Events(this global::System.Windows.Interop.HwndHost item) => new RxHwndHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndHostEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Interop.HwndHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndHostEvents(global::System.Windows.Interop.HwndHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.HwndDpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsGenericResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryUnloaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net471.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net471.winforms.approved.txt new file mode 100644 index 0000000..82fe50c --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net471.winforms.approved.txt @@ -0,0 +1,10568 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolboxItemEvents Events(this global::System.Drawing.Design.ToolboxItem item) => new RxToolboxItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolboxItemEvents + { + private readonly global::System.Drawing.Design.ToolboxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolboxItemEvents(global::System.Drawing.Design.ToolboxItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreated += x, x => _data.ComponentsCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreating += x, x => _data.ComponentsCreating -= x); + } +} + +namespace System.Drawing.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintDocumentEvents Events(this global::System.Drawing.Printing.PrintDocument item) => new RxPrintDocumentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintDocumentEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Drawing.Printing.PrintDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintDocumentEvents(global::System.Drawing.Printing.PrintDocument data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginPrint += x, x => _data.BeginPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndPrint += x, x => _data.EndPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PrintPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintPageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PrintPage += x, x => _data.PrintPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryPageSettings => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.QueryPageSettingsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryPageSettings += x, x => _data.QueryPageSettings -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Forms.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Forms.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridBoolColumnEvents Events(this global::System.Windows.Forms.DataGridBoolColumn item) => new RxDataGridBoolColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnStyleEvents Events(this global::System.Windows.Forms.DataGridColumnStyle item) => new RxDataGridColumnStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridTableStyleEvents Events(this global::System.Windows.Forms.DataGridTableStyle item) => new RxDataGridTableStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridColumnStylesCollectionEvents Events(this global::System.Windows.Forms.GridColumnStylesCollection item) => new RxGridColumnStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridTableStylesCollectionEvents Events(this global::System.Windows.Forms.GridTableStylesCollection item) => new RxGridTableStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMainMenuEvents Events(this global::System.Windows.Forms.MainMenu item) => new RxMainMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Forms.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::System.Windows.Forms.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolBarEvents Events(this global::System.Windows.Forms.ToolBar item) => new RxToolBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Forms.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedAfterParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedAfterParent += x, x => _data.DpiChangedAfterParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedBeforeParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedBeforeParent += x, x => _data.DpiChangedBeforeParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Forms.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNavigationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNavigationChanged += x, x => _data.AllowNavigationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackButtonClick += x, x => _data.BackButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CaptionVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CaptionVisibleChanged += x, x => _data.CaptionVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FlatModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FlatModeChanged += x, x => _data.FlatModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NavigateEventArgs ne) => eventHandler(ne); + return Handler; + }, x => _data.Navigate += x, x => _data.Navigate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsLabelStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsLabelStyleChanged += x, x => _data.ParentRowsLabelStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsVisibleChanged += x, x => _data.ParentRowsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShowParentDetailsButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShowParentDetailsButtonClick += x, x => _data.ShowParentDetailsButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridBoolColumnEvents : global::System.Windows.Forms.RxDataGridColumnStyleEvents + { + private readonly global::System.Windows.Forms.DataGridBoolColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridBoolColumnEvents(global::System.Windows.Forms.DataGridBoolColumn data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNullChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNullChanged += x, x => _data.AllowNullChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FalseValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FalseValueChanged += x, x => _data.FalseValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TrueValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TrueValueChanged += x, x => _data.TrueValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridColumnStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnStyleEvents(global::System.Windows.Forms.DataGridColumnStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlignmentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlignmentChanged += x, x => _data.AlignmentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderTextChanged += x, x => _data.HeaderTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NullTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NullTextChanged += x, x => _data.NullTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDescriptorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDescriptorChanged += x, x => _data.PropertyDescriptorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WidthChanged += x, x => _data.WidthChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridTableStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridTableStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridTableStyleEvents(global::System.Windows.Forms.DataGridTableStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowSortingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowSortingChanged += x, x => _data.AllowSortingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingBackColorChanged += x, x => _data.AlternatingBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersVisibleChanged += x, x => _data.ColumnHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineColorChanged += x, x => _data.GridLineColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineStyleChanged += x, x => _data.GridLineStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderBackColorChanged += x, x => _data.HeaderBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderFontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderFontChanged += x, x => _data.HeaderFontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderForeColorChanged += x, x => _data.HeaderForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkColorChanged += x, x => _data.LinkColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkHoverColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkHoverColorChanged += x, x => _data.LinkHoverColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredColumnWidthChanged += x, x => _data.PreferredColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredRowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredRowHeightChanged += x, x => _data.PreferredRowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersVisibleChanged += x, x => _data.RowHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderWidthChanged += x, x => _data.RowHeaderWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionBackColorChanged += x, x => _data.SelectionBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionForeColorChanged += x, x => _data.SelectionForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridColumnStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridColumnStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridColumnStylesCollectionEvents(global::System.Windows.Forms.GridColumnStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridTableStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridTableStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridTableStylesCollectionEvents(global::System.Windows.Forms.GridTableStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMainMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MainMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMainMenuEvents(global::System.Windows.Forms.MainMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Forms.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Select => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Select += x, x => _data.Select -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::System.Windows.Forms.StatusBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarDrawItemEventArgs sbdevent) => eventHandler(sbdevent); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PanelClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarPanelClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PanelClick += x, x => _data.PanelClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ToolBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolBarEvents(global::System.Windows.Forms.ToolBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDropDown += x, x => _data.ButtonDropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net471.wpf.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net471.wpf.approved.txt new file mode 100644 index 0000000..d57d348 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net471.wpf.approved.txt @@ -0,0 +1,7204 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Interop.RxHwndHostEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndHostEvents Events(this global::System.Windows.Interop.HwndHost item) => new RxHwndHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndHostEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Interop.HwndHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndHostEvents(global::System.Windows.Interop.HwndHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.HwndDpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsGenericResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryUnloaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net471.wpf.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net471.wpf.winforms.approved.txt new file mode 100644 index 0000000..1e9d585 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net471.wpf.winforms.approved.txt @@ -0,0 +1,17756 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolboxItemEvents Events(this global::System.Drawing.Design.ToolboxItem item) => new RxToolboxItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolboxItemEvents + { + private readonly global::System.Drawing.Design.ToolboxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolboxItemEvents(global::System.Drawing.Design.ToolboxItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreated += x, x => _data.ComponentsCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreating += x, x => _data.ComponentsCreating -= x); + } +} + +namespace System.Drawing.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintDocumentEvents Events(this global::System.Drawing.Printing.PrintDocument item) => new RxPrintDocumentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintDocumentEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Drawing.Printing.PrintDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintDocumentEvents(global::System.Drawing.Printing.PrintDocument data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginPrint += x, x => _data.BeginPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndPrint += x, x => _data.EndPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PrintPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintPageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PrintPage += x, x => _data.PrintPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryPageSettings => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.QueryPageSettingsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryPageSettings += x, x => _data.QueryPageSettings -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Interop.RxHwndHostEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Forms.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Forms.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridBoolColumnEvents Events(this global::System.Windows.Forms.DataGridBoolColumn item) => new RxDataGridBoolColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnStyleEvents Events(this global::System.Windows.Forms.DataGridColumnStyle item) => new RxDataGridColumnStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridTableStyleEvents Events(this global::System.Windows.Forms.DataGridTableStyle item) => new RxDataGridTableStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridColumnStylesCollectionEvents Events(this global::System.Windows.Forms.GridColumnStylesCollection item) => new RxGridColumnStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridTableStylesCollectionEvents Events(this global::System.Windows.Forms.GridTableStylesCollection item) => new RxGridTableStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMainMenuEvents Events(this global::System.Windows.Forms.MainMenu item) => new RxMainMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Forms.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::System.Windows.Forms.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolBarEvents Events(this global::System.Windows.Forms.ToolBar item) => new RxToolBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Forms.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedAfterParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedAfterParent += x, x => _data.DpiChangedAfterParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedBeforeParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedBeforeParent += x, x => _data.DpiChangedBeforeParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Forms.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNavigationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNavigationChanged += x, x => _data.AllowNavigationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackButtonClick += x, x => _data.BackButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CaptionVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CaptionVisibleChanged += x, x => _data.CaptionVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FlatModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FlatModeChanged += x, x => _data.FlatModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NavigateEventArgs ne) => eventHandler(ne); + return Handler; + }, x => _data.Navigate += x, x => _data.Navigate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsLabelStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsLabelStyleChanged += x, x => _data.ParentRowsLabelStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsVisibleChanged += x, x => _data.ParentRowsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShowParentDetailsButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShowParentDetailsButtonClick += x, x => _data.ShowParentDetailsButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridBoolColumnEvents : global::System.Windows.Forms.RxDataGridColumnStyleEvents + { + private readonly global::System.Windows.Forms.DataGridBoolColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridBoolColumnEvents(global::System.Windows.Forms.DataGridBoolColumn data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNullChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNullChanged += x, x => _data.AllowNullChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FalseValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FalseValueChanged += x, x => _data.FalseValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TrueValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TrueValueChanged += x, x => _data.TrueValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridColumnStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnStyleEvents(global::System.Windows.Forms.DataGridColumnStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlignmentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlignmentChanged += x, x => _data.AlignmentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderTextChanged += x, x => _data.HeaderTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NullTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NullTextChanged += x, x => _data.NullTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDescriptorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDescriptorChanged += x, x => _data.PropertyDescriptorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WidthChanged += x, x => _data.WidthChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridTableStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridTableStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridTableStyleEvents(global::System.Windows.Forms.DataGridTableStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowSortingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowSortingChanged += x, x => _data.AllowSortingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingBackColorChanged += x, x => _data.AlternatingBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersVisibleChanged += x, x => _data.ColumnHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineColorChanged += x, x => _data.GridLineColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineStyleChanged += x, x => _data.GridLineStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderBackColorChanged += x, x => _data.HeaderBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderFontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderFontChanged += x, x => _data.HeaderFontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderForeColorChanged += x, x => _data.HeaderForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkColorChanged += x, x => _data.LinkColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkHoverColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkHoverColorChanged += x, x => _data.LinkHoverColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredColumnWidthChanged += x, x => _data.PreferredColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredRowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredRowHeightChanged += x, x => _data.PreferredRowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersVisibleChanged += x, x => _data.RowHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderWidthChanged += x, x => _data.RowHeaderWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionBackColorChanged += x, x => _data.SelectionBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionForeColorChanged += x, x => _data.SelectionForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridColumnStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridColumnStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridColumnStylesCollectionEvents(global::System.Windows.Forms.GridColumnStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridTableStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridTableStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridTableStylesCollectionEvents(global::System.Windows.Forms.GridTableStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMainMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MainMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMainMenuEvents(global::System.Windows.Forms.MainMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Forms.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Select => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Select += x, x => _data.Select -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::System.Windows.Forms.StatusBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarDrawItemEventArgs sbdevent) => eventHandler(sbdevent); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PanelClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarPanelClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PanelClick += x, x => _data.PanelClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ToolBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolBarEvents(global::System.Windows.Forms.ToolBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDropDown += x, x => _data.ButtonDropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndHostEvents Events(this global::System.Windows.Interop.HwndHost item) => new RxHwndHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndHostEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Interop.HwndHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndHostEvents(global::System.Windows.Interop.HwndHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.HwndDpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsGenericResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryUnloaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net472.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net472.winforms.approved.txt new file mode 100644 index 0000000..82fe50c --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net472.winforms.approved.txt @@ -0,0 +1,10568 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolboxItemEvents Events(this global::System.Drawing.Design.ToolboxItem item) => new RxToolboxItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolboxItemEvents + { + private readonly global::System.Drawing.Design.ToolboxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolboxItemEvents(global::System.Drawing.Design.ToolboxItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreated += x, x => _data.ComponentsCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreating += x, x => _data.ComponentsCreating -= x); + } +} + +namespace System.Drawing.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintDocumentEvents Events(this global::System.Drawing.Printing.PrintDocument item) => new RxPrintDocumentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintDocumentEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Drawing.Printing.PrintDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintDocumentEvents(global::System.Drawing.Printing.PrintDocument data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginPrint += x, x => _data.BeginPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndPrint += x, x => _data.EndPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PrintPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintPageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PrintPage += x, x => _data.PrintPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryPageSettings => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.QueryPageSettingsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryPageSettings += x, x => _data.QueryPageSettings -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Forms.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Forms.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridBoolColumnEvents Events(this global::System.Windows.Forms.DataGridBoolColumn item) => new RxDataGridBoolColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnStyleEvents Events(this global::System.Windows.Forms.DataGridColumnStyle item) => new RxDataGridColumnStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridTableStyleEvents Events(this global::System.Windows.Forms.DataGridTableStyle item) => new RxDataGridTableStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridColumnStylesCollectionEvents Events(this global::System.Windows.Forms.GridColumnStylesCollection item) => new RxGridColumnStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridTableStylesCollectionEvents Events(this global::System.Windows.Forms.GridTableStylesCollection item) => new RxGridTableStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMainMenuEvents Events(this global::System.Windows.Forms.MainMenu item) => new RxMainMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Forms.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::System.Windows.Forms.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolBarEvents Events(this global::System.Windows.Forms.ToolBar item) => new RxToolBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Forms.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedAfterParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedAfterParent += x, x => _data.DpiChangedAfterParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedBeforeParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedBeforeParent += x, x => _data.DpiChangedBeforeParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Forms.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNavigationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNavigationChanged += x, x => _data.AllowNavigationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackButtonClick += x, x => _data.BackButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CaptionVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CaptionVisibleChanged += x, x => _data.CaptionVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FlatModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FlatModeChanged += x, x => _data.FlatModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NavigateEventArgs ne) => eventHandler(ne); + return Handler; + }, x => _data.Navigate += x, x => _data.Navigate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsLabelStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsLabelStyleChanged += x, x => _data.ParentRowsLabelStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsVisibleChanged += x, x => _data.ParentRowsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShowParentDetailsButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShowParentDetailsButtonClick += x, x => _data.ShowParentDetailsButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridBoolColumnEvents : global::System.Windows.Forms.RxDataGridColumnStyleEvents + { + private readonly global::System.Windows.Forms.DataGridBoolColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridBoolColumnEvents(global::System.Windows.Forms.DataGridBoolColumn data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNullChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNullChanged += x, x => _data.AllowNullChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FalseValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FalseValueChanged += x, x => _data.FalseValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TrueValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TrueValueChanged += x, x => _data.TrueValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridColumnStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnStyleEvents(global::System.Windows.Forms.DataGridColumnStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlignmentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlignmentChanged += x, x => _data.AlignmentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderTextChanged += x, x => _data.HeaderTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NullTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NullTextChanged += x, x => _data.NullTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDescriptorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDescriptorChanged += x, x => _data.PropertyDescriptorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WidthChanged += x, x => _data.WidthChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridTableStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridTableStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridTableStyleEvents(global::System.Windows.Forms.DataGridTableStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowSortingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowSortingChanged += x, x => _data.AllowSortingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingBackColorChanged += x, x => _data.AlternatingBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersVisibleChanged += x, x => _data.ColumnHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineColorChanged += x, x => _data.GridLineColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineStyleChanged += x, x => _data.GridLineStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderBackColorChanged += x, x => _data.HeaderBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderFontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderFontChanged += x, x => _data.HeaderFontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderForeColorChanged += x, x => _data.HeaderForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkColorChanged += x, x => _data.LinkColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkHoverColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkHoverColorChanged += x, x => _data.LinkHoverColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredColumnWidthChanged += x, x => _data.PreferredColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredRowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredRowHeightChanged += x, x => _data.PreferredRowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersVisibleChanged += x, x => _data.RowHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderWidthChanged += x, x => _data.RowHeaderWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionBackColorChanged += x, x => _data.SelectionBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionForeColorChanged += x, x => _data.SelectionForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridColumnStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridColumnStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridColumnStylesCollectionEvents(global::System.Windows.Forms.GridColumnStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridTableStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridTableStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridTableStylesCollectionEvents(global::System.Windows.Forms.GridTableStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMainMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MainMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMainMenuEvents(global::System.Windows.Forms.MainMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Forms.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Select => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Select += x, x => _data.Select -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::System.Windows.Forms.StatusBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarDrawItemEventArgs sbdevent) => eventHandler(sbdevent); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PanelClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarPanelClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PanelClick += x, x => _data.PanelClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ToolBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolBarEvents(global::System.Windows.Forms.ToolBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDropDown += x, x => _data.ButtonDropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net472.wpf.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net472.wpf.approved.txt new file mode 100644 index 0000000..ca9d5c4 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net472.wpf.approved.txt @@ -0,0 +1,7212 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Interop.RxHwndHostEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndHostEvents Events(this global::System.Windows.Interop.HwndHost item) => new RxHwndHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndHostEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Interop.HwndHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndHostEvents(global::System.Windows.Interop.HwndHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.HwndDpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsGenericResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsStaticResourceResolved => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryUnloaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net472.wpf.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net472.wpf.winforms.approved.txt new file mode 100644 index 0000000..268132b --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net472.wpf.winforms.approved.txt @@ -0,0 +1,17764 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolboxItemEvents Events(this global::System.Drawing.Design.ToolboxItem item) => new RxToolboxItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolboxItemEvents + { + private readonly global::System.Drawing.Design.ToolboxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolboxItemEvents(global::System.Drawing.Design.ToolboxItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreated += x, x => _data.ComponentsCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreating += x, x => _data.ComponentsCreating -= x); + } +} + +namespace System.Drawing.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintDocumentEvents Events(this global::System.Drawing.Printing.PrintDocument item) => new RxPrintDocumentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintDocumentEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Drawing.Printing.PrintDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintDocumentEvents(global::System.Drawing.Printing.PrintDocument data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginPrint += x, x => _data.BeginPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndPrint += x, x => _data.EndPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PrintPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintPageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PrintPage += x, x => _data.PrintPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryPageSettings => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.QueryPageSettingsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryPageSettings += x, x => _data.QueryPageSettings -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Interop.RxHwndHostEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Forms.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Forms.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridBoolColumnEvents Events(this global::System.Windows.Forms.DataGridBoolColumn item) => new RxDataGridBoolColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnStyleEvents Events(this global::System.Windows.Forms.DataGridColumnStyle item) => new RxDataGridColumnStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridTableStyleEvents Events(this global::System.Windows.Forms.DataGridTableStyle item) => new RxDataGridTableStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridColumnStylesCollectionEvents Events(this global::System.Windows.Forms.GridColumnStylesCollection item) => new RxGridColumnStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridTableStylesCollectionEvents Events(this global::System.Windows.Forms.GridTableStylesCollection item) => new RxGridTableStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMainMenuEvents Events(this global::System.Windows.Forms.MainMenu item) => new RxMainMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Forms.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::System.Windows.Forms.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolBarEvents Events(this global::System.Windows.Forms.ToolBar item) => new RxToolBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Forms.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedAfterParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedAfterParent += x, x => _data.DpiChangedAfterParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedBeforeParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedBeforeParent += x, x => _data.DpiChangedBeforeParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Forms.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNavigationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNavigationChanged += x, x => _data.AllowNavigationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackButtonClick += x, x => _data.BackButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CaptionVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CaptionVisibleChanged += x, x => _data.CaptionVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FlatModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FlatModeChanged += x, x => _data.FlatModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NavigateEventArgs ne) => eventHandler(ne); + return Handler; + }, x => _data.Navigate += x, x => _data.Navigate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsLabelStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsLabelStyleChanged += x, x => _data.ParentRowsLabelStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsVisibleChanged += x, x => _data.ParentRowsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShowParentDetailsButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShowParentDetailsButtonClick += x, x => _data.ShowParentDetailsButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridBoolColumnEvents : global::System.Windows.Forms.RxDataGridColumnStyleEvents + { + private readonly global::System.Windows.Forms.DataGridBoolColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridBoolColumnEvents(global::System.Windows.Forms.DataGridBoolColumn data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNullChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNullChanged += x, x => _data.AllowNullChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FalseValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FalseValueChanged += x, x => _data.FalseValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TrueValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TrueValueChanged += x, x => _data.TrueValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridColumnStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnStyleEvents(global::System.Windows.Forms.DataGridColumnStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlignmentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlignmentChanged += x, x => _data.AlignmentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderTextChanged += x, x => _data.HeaderTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NullTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NullTextChanged += x, x => _data.NullTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDescriptorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDescriptorChanged += x, x => _data.PropertyDescriptorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WidthChanged += x, x => _data.WidthChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridTableStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridTableStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridTableStyleEvents(global::System.Windows.Forms.DataGridTableStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowSortingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowSortingChanged += x, x => _data.AllowSortingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingBackColorChanged += x, x => _data.AlternatingBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersVisibleChanged += x, x => _data.ColumnHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineColorChanged += x, x => _data.GridLineColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineStyleChanged += x, x => _data.GridLineStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderBackColorChanged += x, x => _data.HeaderBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderFontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderFontChanged += x, x => _data.HeaderFontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderForeColorChanged += x, x => _data.HeaderForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkColorChanged += x, x => _data.LinkColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkHoverColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkHoverColorChanged += x, x => _data.LinkHoverColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredColumnWidthChanged += x, x => _data.PreferredColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredRowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredRowHeightChanged += x, x => _data.PreferredRowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersVisibleChanged += x, x => _data.RowHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderWidthChanged += x, x => _data.RowHeaderWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionBackColorChanged += x, x => _data.SelectionBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionForeColorChanged += x, x => _data.SelectionForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridColumnStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridColumnStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridColumnStylesCollectionEvents(global::System.Windows.Forms.GridColumnStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridTableStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridTableStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridTableStylesCollectionEvents(global::System.Windows.Forms.GridTableStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMainMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MainMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMainMenuEvents(global::System.Windows.Forms.MainMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Forms.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Select => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Select += x, x => _data.Select -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::System.Windows.Forms.StatusBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarDrawItemEventArgs sbdevent) => eventHandler(sbdevent); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PanelClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarPanelClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PanelClick += x, x => _data.PanelClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ToolBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolBarEvents(global::System.Windows.Forms.ToolBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDropDown += x, x => _data.ButtonDropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndHostEvents Events(this global::System.Windows.Interop.HwndHost item) => new RxHwndHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndHostEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Interop.HwndHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndHostEvents(global::System.Windows.Interop.HwndHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.HwndDpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsGenericResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsStaticResourceResolved => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryUnloaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net48.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net48.winforms.approved.txt new file mode 100644 index 0000000..82fe50c --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net48.winforms.approved.txt @@ -0,0 +1,10568 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolboxItemEvents Events(this global::System.Drawing.Design.ToolboxItem item) => new RxToolboxItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolboxItemEvents + { + private readonly global::System.Drawing.Design.ToolboxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolboxItemEvents(global::System.Drawing.Design.ToolboxItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreated += x, x => _data.ComponentsCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreating += x, x => _data.ComponentsCreating -= x); + } +} + +namespace System.Drawing.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintDocumentEvents Events(this global::System.Drawing.Printing.PrintDocument item) => new RxPrintDocumentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintDocumentEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Drawing.Printing.PrintDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintDocumentEvents(global::System.Drawing.Printing.PrintDocument data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginPrint += x, x => _data.BeginPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndPrint += x, x => _data.EndPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PrintPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintPageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PrintPage += x, x => _data.PrintPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryPageSettings => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.QueryPageSettingsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryPageSettings += x, x => _data.QueryPageSettings -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Forms.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Forms.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridBoolColumnEvents Events(this global::System.Windows.Forms.DataGridBoolColumn item) => new RxDataGridBoolColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnStyleEvents Events(this global::System.Windows.Forms.DataGridColumnStyle item) => new RxDataGridColumnStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridTableStyleEvents Events(this global::System.Windows.Forms.DataGridTableStyle item) => new RxDataGridTableStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridColumnStylesCollectionEvents Events(this global::System.Windows.Forms.GridColumnStylesCollection item) => new RxGridColumnStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridTableStylesCollectionEvents Events(this global::System.Windows.Forms.GridTableStylesCollection item) => new RxGridTableStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMainMenuEvents Events(this global::System.Windows.Forms.MainMenu item) => new RxMainMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Forms.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::System.Windows.Forms.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolBarEvents Events(this global::System.Windows.Forms.ToolBar item) => new RxToolBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Forms.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedAfterParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedAfterParent += x, x => _data.DpiChangedAfterParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedBeforeParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedBeforeParent += x, x => _data.DpiChangedBeforeParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Forms.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNavigationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNavigationChanged += x, x => _data.AllowNavigationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackButtonClick += x, x => _data.BackButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CaptionVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CaptionVisibleChanged += x, x => _data.CaptionVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FlatModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FlatModeChanged += x, x => _data.FlatModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NavigateEventArgs ne) => eventHandler(ne); + return Handler; + }, x => _data.Navigate += x, x => _data.Navigate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsLabelStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsLabelStyleChanged += x, x => _data.ParentRowsLabelStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsVisibleChanged += x, x => _data.ParentRowsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShowParentDetailsButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShowParentDetailsButtonClick += x, x => _data.ShowParentDetailsButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridBoolColumnEvents : global::System.Windows.Forms.RxDataGridColumnStyleEvents + { + private readonly global::System.Windows.Forms.DataGridBoolColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridBoolColumnEvents(global::System.Windows.Forms.DataGridBoolColumn data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNullChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNullChanged += x, x => _data.AllowNullChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FalseValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FalseValueChanged += x, x => _data.FalseValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TrueValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TrueValueChanged += x, x => _data.TrueValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridColumnStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnStyleEvents(global::System.Windows.Forms.DataGridColumnStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlignmentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlignmentChanged += x, x => _data.AlignmentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderTextChanged += x, x => _data.HeaderTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NullTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NullTextChanged += x, x => _data.NullTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDescriptorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDescriptorChanged += x, x => _data.PropertyDescriptorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WidthChanged += x, x => _data.WidthChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridTableStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridTableStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridTableStyleEvents(global::System.Windows.Forms.DataGridTableStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowSortingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowSortingChanged += x, x => _data.AllowSortingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingBackColorChanged += x, x => _data.AlternatingBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersVisibleChanged += x, x => _data.ColumnHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineColorChanged += x, x => _data.GridLineColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineStyleChanged += x, x => _data.GridLineStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderBackColorChanged += x, x => _data.HeaderBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderFontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderFontChanged += x, x => _data.HeaderFontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderForeColorChanged += x, x => _data.HeaderForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkColorChanged += x, x => _data.LinkColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkHoverColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkHoverColorChanged += x, x => _data.LinkHoverColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredColumnWidthChanged += x, x => _data.PreferredColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredRowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredRowHeightChanged += x, x => _data.PreferredRowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersVisibleChanged += x, x => _data.RowHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderWidthChanged += x, x => _data.RowHeaderWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionBackColorChanged += x, x => _data.SelectionBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionForeColorChanged += x, x => _data.SelectionForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridColumnStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridColumnStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridColumnStylesCollectionEvents(global::System.Windows.Forms.GridColumnStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridTableStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridTableStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridTableStylesCollectionEvents(global::System.Windows.Forms.GridTableStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMainMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MainMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMainMenuEvents(global::System.Windows.Forms.MainMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Forms.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Select => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Select += x, x => _data.Select -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::System.Windows.Forms.StatusBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarDrawItemEventArgs sbdevent) => eventHandler(sbdevent); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PanelClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarPanelClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PanelClick += x, x => _data.PanelClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ToolBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolBarEvents(global::System.Windows.Forms.ToolBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDropDown += x, x => _data.ButtonDropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net48.wpf.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net48.wpf.approved.txt new file mode 100644 index 0000000..ca9d5c4 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net48.wpf.approved.txt @@ -0,0 +1,7212 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Interop.RxHwndHostEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndHostEvents Events(this global::System.Windows.Interop.HwndHost item) => new RxHwndHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndHostEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Interop.HwndHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndHostEvents(global::System.Windows.Interop.HwndHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.HwndDpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsGenericResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsStaticResourceResolved => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryUnloaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net48.wpf.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net48.wpf.winforms.approved.txt new file mode 100644 index 0000000..268132b --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net48.wpf.winforms.approved.txt @@ -0,0 +1,17764 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolboxItemEvents Events(this global::System.Drawing.Design.ToolboxItem item) => new RxToolboxItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolboxItemEvents + { + private readonly global::System.Drawing.Design.ToolboxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolboxItemEvents(global::System.Drawing.Design.ToolboxItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreated += x, x => _data.ComponentsCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComponentsCreating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Design.ToolboxComponentsCreatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComponentsCreating += x, x => _data.ComponentsCreating -= x); + } +} + +namespace System.Drawing.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintDocumentEvents Events(this global::System.Drawing.Printing.PrintDocument item) => new RxPrintDocumentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintDocumentEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Drawing.Printing.PrintDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintDocumentEvents(global::System.Drawing.Printing.PrintDocument data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginPrint += x, x => _data.BeginPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndPrint += x, x => _data.EndPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PrintPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.PrintPageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PrintPage += x, x => _data.PrintPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryPageSettings => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Drawing.Printing.QueryPageSettingsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryPageSettings += x, x => _data.QueryPageSettings -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Interop.RxHwndHostEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Forms.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Forms.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridBoolColumnEvents Events(this global::System.Windows.Forms.DataGridBoolColumn item) => new RxDataGridBoolColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnStyleEvents Events(this global::System.Windows.Forms.DataGridColumnStyle item) => new RxDataGridColumnStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridTableStyleEvents Events(this global::System.Windows.Forms.DataGridTableStyle item) => new RxDataGridTableStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridColumnStylesCollectionEvents Events(this global::System.Windows.Forms.GridColumnStylesCollection item) => new RxGridColumnStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridTableStylesCollectionEvents Events(this global::System.Windows.Forms.GridTableStylesCollection item) => new RxGridTableStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMainMenuEvents Events(this global::System.Windows.Forms.MainMenu item) => new RxMainMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Forms.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::System.Windows.Forms.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolBarEvents Events(this global::System.Windows.Forms.ToolBar item) => new RxToolBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Forms.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedAfterParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedAfterParent += x, x => _data.DpiChangedAfterParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedBeforeParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedBeforeParent += x, x => _data.DpiChangedBeforeParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Forms.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNavigationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNavigationChanged += x, x => _data.AllowNavigationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackButtonClick += x, x => _data.BackButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CaptionVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CaptionVisibleChanged += x, x => _data.CaptionVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FlatModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FlatModeChanged += x, x => _data.FlatModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NavigateEventArgs ne) => eventHandler(ne); + return Handler; + }, x => _data.Navigate += x, x => _data.Navigate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsLabelStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsLabelStyleChanged += x, x => _data.ParentRowsLabelStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsVisibleChanged += x, x => _data.ParentRowsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShowParentDetailsButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShowParentDetailsButtonClick += x, x => _data.ShowParentDetailsButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridBoolColumnEvents : global::System.Windows.Forms.RxDataGridColumnStyleEvents + { + private readonly global::System.Windows.Forms.DataGridBoolColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridBoolColumnEvents(global::System.Windows.Forms.DataGridBoolColumn data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNullChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNullChanged += x, x => _data.AllowNullChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FalseValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FalseValueChanged += x, x => _data.FalseValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TrueValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TrueValueChanged += x, x => _data.TrueValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridColumnStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnStyleEvents(global::System.Windows.Forms.DataGridColumnStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlignmentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlignmentChanged += x, x => _data.AlignmentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderTextChanged += x, x => _data.HeaderTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NullTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NullTextChanged += x, x => _data.NullTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDescriptorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDescriptorChanged += x, x => _data.PropertyDescriptorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WidthChanged += x, x => _data.WidthChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridTableStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridTableStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridTableStyleEvents(global::System.Windows.Forms.DataGridTableStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowSortingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowSortingChanged += x, x => _data.AllowSortingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingBackColorChanged += x, x => _data.AlternatingBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersVisibleChanged += x, x => _data.ColumnHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineColorChanged += x, x => _data.GridLineColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineStyleChanged += x, x => _data.GridLineStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderBackColorChanged += x, x => _data.HeaderBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderFontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderFontChanged += x, x => _data.HeaderFontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderForeColorChanged += x, x => _data.HeaderForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkColorChanged += x, x => _data.LinkColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkHoverColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkHoverColorChanged += x, x => _data.LinkHoverColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredColumnWidthChanged += x, x => _data.PreferredColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredRowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredRowHeightChanged += x, x => _data.PreferredRowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersVisibleChanged += x, x => _data.RowHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderWidthChanged += x, x => _data.RowHeaderWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionBackColorChanged += x, x => _data.SelectionBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionForeColorChanged += x, x => _data.SelectionForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridColumnStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridColumnStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridColumnStylesCollectionEvents(global::System.Windows.Forms.GridColumnStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridTableStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridTableStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridTableStylesCollectionEvents(global::System.Windows.Forms.GridTableStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMainMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MainMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMainMenuEvents(global::System.Windows.Forms.MainMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Forms.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Select => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Select += x, x => _data.Select -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::System.Windows.Forms.StatusBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarDrawItemEventArgs sbdevent) => eventHandler(sbdevent); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PanelClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarPanelClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PanelClick += x, x => _data.PanelClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ToolBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolBarEvents(global::System.Windows.Forms.ToolBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDropDown += x, x => _data.ButtonDropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndHostEvents Events(this global::System.Windows.Interop.HwndHost item) => new RxHwndHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndHostEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Interop.HwndHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndHostEvents(global::System.Windows.Interop.HwndHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.HwndDpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsGenericResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsStaticResourceResolved => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryUnloaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net5.0.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net5.0.winforms.approved.txt new file mode 100644 index 0000000..37cc3e7 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net5.0.winforms.approved.txt @@ -0,0 +1,9758 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTaskDialogButtonEvents Events(this global::System.Windows.Forms.TaskDialogButton item) => new RxTaskDialogButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTaskDialogExpanderEvents Events(this global::System.Windows.Forms.TaskDialogExpander item) => new RxTaskDialogExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTaskDialogPageEvents Events(this global::System.Windows.Forms.TaskDialogPage item) => new RxTaskDialogPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTaskDialogRadioButtonEvents Events(this global::System.Windows.Forms.TaskDialogRadioButton item) => new RxTaskDialogRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTaskDialogVerificationCheckBoxEvents Events(this global::System.Windows.Forms.TaskDialogVerificationCheckBox item) => new RxTaskDialogVerificationCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedAfterParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedAfterParent += x, x => _data.DpiChangedAfterParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedBeforeParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedBeforeParent += x, x => _data.DpiChangedBeforeParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GroupCollapsedStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Forms.ListViewGroupEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewGroupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GroupCollapsedStateChanged += x, x => _data.GroupCollapsedStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GroupTaskLinkClick => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Forms.ListViewGroupEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewGroupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GroupTaskLinkClick += x, x => _data.GroupTaskLinkClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTaskDialogButtonEvents + { + private readonly global::System.Windows.Forms.TaskDialogButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTaskDialogButtonEvents(global::System.Windows.Forms.TaskDialogButton data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTaskDialogExpanderEvents + { + private readonly global::System.Windows.Forms.TaskDialogExpander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTaskDialogExpanderEvents(global::System.Windows.Forms.TaskDialogExpander data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ExpandedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ExpandedChanged += x, x => _data.ExpandedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTaskDialogPageEvents + { + private readonly global::System.Windows.Forms.TaskDialogPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTaskDialogPageEvents(global::System.Windows.Forms.TaskDialogPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Created => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Created += x, x => _data.Created -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTaskDialogRadioButtonEvents + { + private readonly global::System.Windows.Forms.TaskDialogRadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTaskDialogRadioButtonEvents(global::System.Windows.Forms.TaskDialogRadioButton data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTaskDialogVerificationCheckBoxEvents + { + private readonly global::System.Windows.Forms.TaskDialogVerificationCheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTaskDialogVerificationCheckBoxEvents(global::System.Windows.Forms.TaskDialogVerificationCheckBox data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net5.0.wpf.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net5.0.wpf.approved.txt new file mode 100644 index 0000000..7a4758a --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net5.0.wpf.approved.txt @@ -0,0 +1,7220 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Interop.RxHwndHostEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndHostEvents Events(this global::System.Windows.Interop.HwndHost item) => new RxHwndHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndHostEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Interop.HwndHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndHostEvents(global::System.Windows.Interop.HwndHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.HwndDpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingDiagnosticsBindingFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.BindingFailedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.BindingFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.BindingDiagnostics.BindingFailed += x, x => global::System.Windows.Diagnostics.BindingDiagnostics.BindingFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsGenericResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsStaticResourceResolved => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryUnloaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net5.0.wpf.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net5.0.wpf.winforms.approved.txt new file mode 100644 index 0000000..490a99f --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/net5.0.wpf.winforms.approved.txt @@ -0,0 +1,16962 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Interop.RxHwndHostEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTaskDialogButtonEvents Events(this global::System.Windows.Forms.TaskDialogButton item) => new RxTaskDialogButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTaskDialogExpanderEvents Events(this global::System.Windows.Forms.TaskDialogExpander item) => new RxTaskDialogExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTaskDialogPageEvents Events(this global::System.Windows.Forms.TaskDialogPage item) => new RxTaskDialogPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTaskDialogRadioButtonEvents Events(this global::System.Windows.Forms.TaskDialogRadioButton item) => new RxTaskDialogRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTaskDialogVerificationCheckBoxEvents Events(this global::System.Windows.Forms.TaskDialogVerificationCheckBox item) => new RxTaskDialogVerificationCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedAfterParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedAfterParent += x, x => _data.DpiChangedAfterParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedBeforeParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedBeforeParent += x, x => _data.DpiChangedBeforeParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GroupCollapsedStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Forms.ListViewGroupEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewGroupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GroupCollapsedStateChanged += x, x => _data.GroupCollapsedStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GroupTaskLinkClick => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Forms.ListViewGroupEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewGroupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GroupTaskLinkClick += x, x => _data.GroupTaskLinkClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTaskDialogButtonEvents + { + private readonly global::System.Windows.Forms.TaskDialogButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTaskDialogButtonEvents(global::System.Windows.Forms.TaskDialogButton data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTaskDialogExpanderEvents + { + private readonly global::System.Windows.Forms.TaskDialogExpander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTaskDialogExpanderEvents(global::System.Windows.Forms.TaskDialogExpander data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ExpandedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ExpandedChanged += x, x => _data.ExpandedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTaskDialogPageEvents + { + private readonly global::System.Windows.Forms.TaskDialogPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTaskDialogPageEvents(global::System.Windows.Forms.TaskDialogPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Created => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Created += x, x => _data.Created -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTaskDialogRadioButtonEvents + { + private readonly global::System.Windows.Forms.TaskDialogRadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTaskDialogRadioButtonEvents(global::System.Windows.Forms.TaskDialogRadioButton data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTaskDialogVerificationCheckBoxEvents + { + private readonly global::System.Windows.Forms.TaskDialogVerificationCheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTaskDialogVerificationCheckBoxEvents(global::System.Windows.Forms.TaskDialogVerificationCheckBox data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndHostEvents Events(this global::System.Windows.Interop.HwndHost item) => new RxHwndHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndHostEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Interop.HwndHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndHostEvents(global::System.Windows.Interop.HwndHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.HwndDpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingDiagnosticsBindingFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.BindingFailedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.BindingFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.BindingDiagnostics.BindingFailed += x, x => global::System.Windows.Diagnostics.BindingDiagnostics.BindingFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsGenericResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsStaticResourceResolved => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryUnloaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.0.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.0.winforms.approved.txt new file mode 100644 index 0000000..e4f73f4 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.0.winforms.approved.txt @@ -0,0 +1,10468 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Forms.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Forms.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridBoolColumnEvents Events(this global::System.Windows.Forms.DataGridBoolColumn item) => new RxDataGridBoolColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnStyleEvents Events(this global::System.Windows.Forms.DataGridColumnStyle item) => new RxDataGridColumnStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridTableStyleEvents Events(this global::System.Windows.Forms.DataGridTableStyle item) => new RxDataGridTableStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridColumnStylesCollectionEvents Events(this global::System.Windows.Forms.GridColumnStylesCollection item) => new RxGridColumnStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridTableStylesCollectionEvents Events(this global::System.Windows.Forms.GridTableStylesCollection item) => new RxGridTableStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMainMenuEvents Events(this global::System.Windows.Forms.MainMenu item) => new RxMainMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Forms.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::System.Windows.Forms.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolBarEvents Events(this global::System.Windows.Forms.ToolBar item) => new RxToolBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Forms.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedAfterParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedAfterParent += x, x => _data.DpiChangedAfterParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedBeforeParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedBeforeParent += x, x => _data.DpiChangedBeforeParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Forms.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNavigationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNavigationChanged += x, x => _data.AllowNavigationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackButtonClick += x, x => _data.BackButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CaptionVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CaptionVisibleChanged += x, x => _data.CaptionVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FlatModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FlatModeChanged += x, x => _data.FlatModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NavigateEventArgs ne) => eventHandler(ne); + return Handler; + }, x => _data.Navigate += x, x => _data.Navigate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsLabelStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsLabelStyleChanged += x, x => _data.ParentRowsLabelStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsVisibleChanged += x, x => _data.ParentRowsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShowParentDetailsButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShowParentDetailsButtonClick += x, x => _data.ShowParentDetailsButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridBoolColumnEvents : global::System.Windows.Forms.RxDataGridColumnStyleEvents + { + private readonly global::System.Windows.Forms.DataGridBoolColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridBoolColumnEvents(global::System.Windows.Forms.DataGridBoolColumn data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNullChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNullChanged += x, x => _data.AllowNullChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FalseValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FalseValueChanged += x, x => _data.FalseValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TrueValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TrueValueChanged += x, x => _data.TrueValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridColumnStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnStyleEvents(global::System.Windows.Forms.DataGridColumnStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlignmentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlignmentChanged += x, x => _data.AlignmentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderTextChanged += x, x => _data.HeaderTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NullTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NullTextChanged += x, x => _data.NullTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDescriptorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDescriptorChanged += x, x => _data.PropertyDescriptorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WidthChanged += x, x => _data.WidthChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridTableStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridTableStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridTableStyleEvents(global::System.Windows.Forms.DataGridTableStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowSortingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowSortingChanged += x, x => _data.AllowSortingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingBackColorChanged += x, x => _data.AlternatingBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersVisibleChanged += x, x => _data.ColumnHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineColorChanged += x, x => _data.GridLineColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineStyleChanged += x, x => _data.GridLineStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderBackColorChanged += x, x => _data.HeaderBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderFontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderFontChanged += x, x => _data.HeaderFontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderForeColorChanged += x, x => _data.HeaderForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkColorChanged += x, x => _data.LinkColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkHoverColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkHoverColorChanged += x, x => _data.LinkHoverColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredColumnWidthChanged += x, x => _data.PreferredColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredRowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredRowHeightChanged += x, x => _data.PreferredRowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersVisibleChanged += x, x => _data.RowHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderWidthChanged += x, x => _data.RowHeaderWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionBackColorChanged += x, x => _data.SelectionBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionForeColorChanged += x, x => _data.SelectionForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridColumnStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridColumnStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridColumnStylesCollectionEvents(global::System.Windows.Forms.GridColumnStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridTableStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridTableStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridTableStylesCollectionEvents(global::System.Windows.Forms.GridTableStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMainMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MainMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMainMenuEvents(global::System.Windows.Forms.MainMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Forms.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Select => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Select += x, x => _data.Select -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::System.Windows.Forms.StatusBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarDrawItemEventArgs sbdevent) => eventHandler(sbdevent); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PanelClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarPanelClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PanelClick += x, x => _data.PanelClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ToolBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolBarEvents(global::System.Windows.Forms.ToolBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDropDown += x, x => _data.ButtonDropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.0.wpf.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.0.wpf.approved.txt new file mode 100644 index 0000000..ca9d5c4 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.0.wpf.approved.txt @@ -0,0 +1,7212 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Interop.RxHwndHostEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndHostEvents Events(this global::System.Windows.Interop.HwndHost item) => new RxHwndHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndHostEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Interop.HwndHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndHostEvents(global::System.Windows.Interop.HwndHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.HwndDpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsGenericResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsStaticResourceResolved => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryUnloaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.0.wpf.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.0.wpf.winforms.approved.txt new file mode 100644 index 0000000..97c65d7 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.0.wpf.winforms.approved.txt @@ -0,0 +1,17664 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Interop.RxHwndHostEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Forms.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Forms.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridBoolColumnEvents Events(this global::System.Windows.Forms.DataGridBoolColumn item) => new RxDataGridBoolColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnStyleEvents Events(this global::System.Windows.Forms.DataGridColumnStyle item) => new RxDataGridColumnStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridTableStyleEvents Events(this global::System.Windows.Forms.DataGridTableStyle item) => new RxDataGridTableStyleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridColumnStylesCollectionEvents Events(this global::System.Windows.Forms.GridColumnStylesCollection item) => new RxGridColumnStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGridTableStylesCollectionEvents Events(this global::System.Windows.Forms.GridTableStylesCollection item) => new RxGridTableStylesCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMainMenuEvents Events(this global::System.Windows.Forms.MainMenu item) => new RxMainMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Forms.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::System.Windows.Forms.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolBarEvents Events(this global::System.Windows.Forms.ToolBar item) => new RxToolBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Forms.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedAfterParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedAfterParent += x, x => _data.DpiChangedAfterParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedBeforeParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedBeforeParent += x, x => _data.DpiChangedBeforeParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Forms.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNavigationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNavigationChanged += x, x => _data.AllowNavigationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackButtonClick += x, x => _data.BackButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CaptionVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CaptionVisibleChanged += x, x => _data.CaptionVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FlatModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FlatModeChanged += x, x => _data.FlatModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NavigateEventArgs ne) => eventHandler(ne); + return Handler; + }, x => _data.Navigate += x, x => _data.Navigate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsLabelStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsLabelStyleChanged += x, x => _data.ParentRowsLabelStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentRowsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentRowsVisibleChanged += x, x => _data.ParentRowsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShowParentDetailsButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShowParentDetailsButtonClick += x, x => _data.ShowParentDetailsButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridBoolColumnEvents : global::System.Windows.Forms.RxDataGridColumnStyleEvents + { + private readonly global::System.Windows.Forms.DataGridBoolColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridBoolColumnEvents(global::System.Windows.Forms.DataGridBoolColumn data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowNullChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowNullChanged += x, x => _data.AllowNullChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FalseValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FalseValueChanged += x, x => _data.FalseValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TrueValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TrueValueChanged += x, x => _data.TrueValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridColumnStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnStyleEvents(global::System.Windows.Forms.DataGridColumnStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlignmentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlignmentChanged += x, x => _data.AlignmentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderTextChanged += x, x => _data.HeaderTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NullTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NullTextChanged += x, x => _data.NullTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDescriptorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDescriptorChanged += x, x => _data.PropertyDescriptorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WidthChanged += x, x => _data.WidthChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridTableStyleEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.DataGridTableStyle _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridTableStyleEvents(global::System.Windows.Forms.DataGridTableStyle data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowSortingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowSortingChanged += x, x => _data.AllowSortingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingBackColorChanged += x, x => _data.AlternatingBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersVisibleChanged += x, x => _data.ColumnHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineColorChanged += x, x => _data.GridLineColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridLineStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridLineStyleChanged += x, x => _data.GridLineStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderBackColorChanged += x, x => _data.HeaderBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderFontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderFontChanged += x, x => _data.HeaderFontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HeaderForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HeaderForeColorChanged += x, x => _data.HeaderForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkColorChanged += x, x => _data.LinkColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkHoverColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkHoverColorChanged += x, x => _data.LinkHoverColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MappingNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MappingNameChanged += x, x => _data.MappingNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredColumnWidthChanged += x, x => _data.PreferredColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreferredRowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreferredRowHeightChanged += x, x => _data.PreferredRowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersVisibleChanged += x, x => _data.RowHeadersVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderWidthChanged += x, x => _data.RowHeaderWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionBackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionBackColorChanged += x, x => _data.SelectionBackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionForeColorChanged += x, x => _data.SelectionForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridColumnStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridColumnStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridColumnStylesCollectionEvents(global::System.Windows.Forms.GridColumnStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGridTableStylesCollectionEvents + { + private readonly global::System.Windows.Forms.GridTableStylesCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGridTableStylesCollectionEvents(global::System.Windows.Forms.GridTableStylesCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMainMenuEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MainMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMainMenuEvents(global::System.Windows.Forms.MainMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapse += x, x => _data.Collapse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Forms.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Select => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Select += x, x => _data.Select -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::System.Windows.Forms.StatusBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarDrawItemEventArgs sbdevent) => eventHandler(sbdevent); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PanelClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarPanelClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PanelClick += x, x => _data.PanelClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ToolBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolBarEvents(global::System.Windows.Forms.ToolBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolBarButtonClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDropDown += x, x => _data.ButtonDropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuChanged += x, x => _data.ContextMenuChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndHostEvents Events(this global::System.Windows.Interop.HwndHost item) => new RxHwndHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndHostEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Interop.HwndHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndHostEvents(global::System.Windows.Interop.HwndHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.HwndDpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsGenericResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsStaticResourceResolved => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryUnloaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.1.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.1.winforms.approved.txt new file mode 100644 index 0000000..b5e3952 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.1.winforms.approved.txt @@ -0,0 +1,9666 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::System.Windows.Forms.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedAfterParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedAfterParent += x, x => _data.DpiChangedAfterParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedBeforeParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedBeforeParent += x, x => _data.DpiChangedBeforeParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::System.Windows.Forms.StatusBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarDrawItemEventArgs sbdevent) => eventHandler(sbdevent); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PanelClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarPanelClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PanelClick += x, x => _data.PanelClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.1.wpf.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.1.wpf.approved.txt new file mode 100644 index 0000000..ca9d5c4 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.1.wpf.approved.txt @@ -0,0 +1,7212 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Interop.RxHwndHostEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndHostEvents Events(this global::System.Windows.Interop.HwndHost item) => new RxHwndHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndHostEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Interop.HwndHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndHostEvents(global::System.Windows.Interop.HwndHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.HwndDpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsGenericResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsStaticResourceResolved => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryUnloaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.1.wpf.winforms.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.1.wpf.winforms.approved.txt new file mode 100644 index 0000000..d46270a --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/netcoreapp3.1.wpf.winforms.approved.txt @@ -0,0 +1,16862 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Microsoft.Win32 +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::Microsoft.Win32.FileDialog item) => new RxFileDialogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents + { + private readonly global::Microsoft.Win32.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::Microsoft.Win32.FileDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } +} + +namespace System.ComponentModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEvents Events(this global::System.ComponentModel.Component item) => new RxComponentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::System.ComponentModel.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEvents + { + private readonly global::System.ComponentModel.Component _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEvents(global::System.ComponentModel.Component data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::System.ComponentModel.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::System.ComponentModel.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace System.Drawing.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPropertyValueUIServiceEvents Events(this global::System.Drawing.Design.IPropertyValueUIService item) => new RxIPropertyValueUIServiceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPropertyValueUIServiceEvents + { + private readonly global::System.Drawing.Design.IPropertyValueUIService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPropertyValueUIServiceEvents(global::System.Drawing.Design.IPropertyValueUIService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyUIValueItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyUIValueItemsChanged += x, x => _data.PropertyUIValueItemsChanged -= x); + } +} + +namespace System.IO.Packaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageDigitalSignatureManagerEvents Events(this global::System.IO.Packaging.PackageDigitalSignatureManager item) => new RxPackageDigitalSignatureManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageDigitalSignatureManagerEvents + { + private readonly global::System.IO.Packaging.PackageDigitalSignatureManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageDigitalSignatureManagerEvents(global::System.IO.Packaging.PackageDigitalSignatureManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidSignatureEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.IO.Packaging.SignatureVerificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidSignatureEvent += x, x => _data.InvalidSignatureEvent -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::System.Windows.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentElementEvents Events(this global::System.Windows.ContentElement item) => new RxContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkContentElementEvents Events(this global::System.Windows.FrameworkContentElement item) => new RxFrameworkContentElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::System.Windows.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFreezableEvents Events(this global::System.Windows.Freezable item) => new RxFreezableEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIInputElementEvents Events(this global::System.Windows.IInputElement item) => new RxIInputElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPresentationSourceEvents Events(this global::System.Windows.PresentationSource item) => new RxPresentationSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::System.Windows.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElement3DEvents Events(this global::System.Windows.UIElement3D item) => new RxUIElement3DEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::System.Windows.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::System.Windows.Window item) => new RxWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::System.Windows.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::System.Windows.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherUnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherUnhandledException += x, x => _data.DispatcherUnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Exit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.ExitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Exit += x, x => _data.Exit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SessionEnding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SessionEndingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SessionEnding += x, x => _data.SessionEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Startup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.StartupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Startup += x, x => _data.Startup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentElementEvents + { + private readonly global::System.Windows.ContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentElementEvents(global::System.Windows.ContentElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkContentElementEvents : global::System.Windows.RxContentElementEvents + { + private readonly global::System.Windows.FrameworkContentElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkContentElementEvents(global::System.Windows.FrameworkContentElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::System.Windows.RxUIElementEvents + { + private readonly global::System.Windows.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::System.Windows.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuClosing += x, x => _data.ContextMenuClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Initialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Initialized += x, x => _data.Initialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestBringIntoView => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RequestBringIntoViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestBringIntoView += x, x => _data.RequestBringIntoView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TargetUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.DataTransferEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.DataTransferEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TargetUpdated += x, x => _data.TargetUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipClosing += x, x => _data.ToolTipClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ToolTipOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ToolTipOpening += x, x => _data.ToolTipOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFreezableEvents + { + private readonly global::System.Windows.Freezable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFreezableEvents(global::System.Windows.Freezable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIInputElementEvents + { + private readonly global::System.Windows.IInputElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIInputElementEvents(global::System.Windows.IInputElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPresentationSourceEvents + { + private readonly global::System.Windows.PresentationSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPresentationSourceEvents(global::System.Windows.PresentationSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::System.Windows.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::System.Windows.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationBoundaryFeedback => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationBoundaryFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationBoundaryFeedback += x, x => _data.ManipulationBoundaryFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationInertiaStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationInertiaStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.ManipulationStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ManipulationStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElement3DEvents + { + private readonly global::System.Windows.UIElement3D _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElement3DEvents(global::System.Windows.UIElement3D data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FocusableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FocusableChanged += x, x => _data.FocusableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotKeyboardFocus += x, x => _data.GotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotMouseCapture += x, x => _data.GotMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotStylusCapture += x, x => _data.GotStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotTouchCapture += x, x => _data.GotTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsHitTestVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsHitTestVisibleChanged += x, x => _data.IsHitTestVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusedChanged += x, x => _data.IsKeyboardFocusedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsKeyboardFocusWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsKeyboardFocusWithinChanged += x, x => _data.IsKeyboardFocusWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCapturedChanged += x, x => _data.IsMouseCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseCaptureWithinChanged += x, x => _data.IsMouseCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsMouseDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsMouseDirectlyOverChanged += x, x => _data.IsMouseDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCapturedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCapturedChanged += x, x => _data.IsStylusCapturedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusCaptureWithinChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusCaptureWithinChanged += x, x => _data.IsStylusCaptureWithinChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsStylusDirectlyOverChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsStylusDirectlyOverChanged += x, x => _data.IsStylusDirectlyOverChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostKeyboardFocus += x, x => _data.LostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostMouseCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostMouseCapture += x, x => _data.LostMouseCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostStylusCapture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostStylusCapture += x, x => _data.LostStylusCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostTouchCapture => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostTouchCapture += x, x => _data.LostTouchCapture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonDown += x, x => _data.MouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeftButtonUp += x, x => _data.MouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonDown += x, x => _data.MouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseRightButtonUp += x, x => _data.MouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragEnter += x, x => _data.PreviewDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragLeave += x, x => _data.PreviewDragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDragOver += x, x => _data.PreviewDragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewDrop += x, x => _data.PreviewDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGiveFeedback += x, x => _data.PreviewGiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewGotKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewGotKeyboardFocus += x, x => _data.PreviewGotKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewLostKeyboardFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.KeyboardFocusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewLostKeyboardFocus += x, x => _data.PreviewLostKeyboardFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDown += x, x => _data.PreviewMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonDown += x, x => _data.PreviewMouseLeftButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseLeftButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseLeftButtonUp += x, x => _data.PreviewMouseLeftButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseMove += x, x => _data.PreviewMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonDown += x, x => _data.PreviewMouseRightButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseRightButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseRightButtonUp += x, x => _data.PreviewMouseRightButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseUp += x, x => _data.PreviewMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseWheelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseWheel += x, x => _data.PreviewMouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewQueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewQueryContinueDrag += x, x => _data.PreviewQueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonDown += x, x => _data.PreviewStylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusButtonUp += x, x => _data.PreviewStylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusDown += x, x => _data.PreviewStylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInAirMove += x, x => _data.PreviewStylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusInRange += x, x => _data.PreviewStylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusMove += x, x => _data.PreviewStylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusOutOfRange += x, x => _data.PreviewStylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusSystemGesture += x, x => _data.PreviewStylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewStylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewStylusUp += x, x => _data.PreviewStylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTextInput += x, x => _data.PreviewTextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchDown += x, x => _data.PreviewTouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchMove += x, x => _data.PreviewTouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewTouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewTouchUp += x, x => _data.PreviewTouchUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryCursor => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.QueryCursorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryCursor += x, x => _data.QueryCursor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonDown += x, x => _data.StylusButtonDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusButtonUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusButtonUp += x, x => _data.StylusButtonUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusDown += x, x => _data.StylusDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusEnter += x, x => _data.StylusEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInAirMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInAirMove += x, x => _data.StylusInAirMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusInRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusInRange += x, x => _data.StylusInRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusLeave += x, x => _data.StylusLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusMove += x, x => _data.StylusMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusOutOfRange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusOutOfRange += x, x => _data.StylusOutOfRange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusSystemGesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusSystemGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusSystemGesture += x, x => _data.StylusSystemGesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.StylusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusUp += x, x => _data.StylusUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TextCompositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextInput += x, x => _data.TextInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchEnter => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchEnter += x, x => _data.TouchEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchLeave => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchLeave += x, x => _data.TouchLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchMove => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchMove += x, x => _data.TouchMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUp => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Input.TouchEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUp += x, x => _data.TouchUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::System.Windows.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::System.Windows.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.VisualStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::System.Windows.Window data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SourceInitialized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SourceInitialized += x, x => _data.SourceInitialized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace System.Windows.Annotations +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationEvents Events(this global::System.Windows.Annotations.Annotation item) => new RxAnnotationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationEvents + { + private readonly global::System.Windows.Annotations.Annotation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationEvents(global::System.Windows.Annotations.Annotation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + } +} + +namespace System.Windows.Annotations.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAnnotationStoreEvents Events(this global::System.Windows.Annotations.Storage.AnnotationStore item) => new RxAnnotationStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAnnotationStoreEvents + { + private readonly global::System.Windows.Annotations.Storage.AnnotationStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAnnotationStoreEvents(global::System.Windows.Annotations.Storage.AnnotationStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnchorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnchorChanged += x, x => _data.AnchorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationAuthorChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorChanged += x, x => _data.AuthorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CargoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.AnnotationResourceChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CargoChanged += x, x => _data.CargoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StoreContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Annotations.Storage.StoreContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StoreContentChanged += x, x => _data.StoreContentChanged -= x); + } +} + +namespace System.Windows.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarEvents Events(this global::System.Windows.Controls.Calendar item) => new RxCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDateRangeEvents Events(this global::System.Windows.Controls.CalendarDateRange item) => new RxCalendarDateRangeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContextMenuEvents Events(this global::System.Windows.Controls.ContextMenu item) => new RxContextMenuEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridEvents Events(this global::System.Windows.Controls.DataGrid item) => new RxDataGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridCellEvents Events(this global::System.Windows.Controls.DataGridCell item) => new RxDataGridCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridColumnEvents Events(this global::System.Windows.Controls.DataGridColumn item) => new RxDataGridColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridRowEvents Events(this global::System.Windows.Controls.DataGridRow item) => new RxDataGridRowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::System.Windows.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::System.Windows.Controls.Expander item) => new RxExpanderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::System.Windows.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::System.Windows.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkCanvasEvents Events(this global::System.Windows.Controls.InkCanvas item) => new RxInkCanvasEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::System.Windows.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxItemEvents Events(this global::System.Windows.Controls.ListBoxItem item) => new RxListBoxItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::System.Windows.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuItemEvents Events(this global::System.Windows.Controls.MenuItem item) => new RxMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::System.Windows.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::System.Windows.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewItemEvents Events(this global::System.Windows.Controls.TreeViewItem item) => new RxTreeViewItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Controls.WebBrowser item) => new RxWebBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Calendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarEvents(global::System.Windows.Controls.Calendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarDateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarDateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayDateChanged += x, x => _data.DisplayDateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.CalendarModeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.CalendarModeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionModeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionModeChanged += x, x => _data.SelectionModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDateRangeEvents + { + private readonly global::System.Windows.Controls.CalendarDateRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDateRangeEvents(global::System.Windows.Controls.CalendarDateRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContextMenuEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ContextMenu _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContextMenuEvents(global::System.Windows.Controls.ContextMenu data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.MouseButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewMouseDoubleClick += x, x => _data.PreviewMouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridEvents : global::System.Windows.Controls.Primitives.RxSelectorEvents + { + private readonly global::System.Windows.Controls.DataGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridEvents(global::System.Windows.Controls.DataGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNewItem => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.AddingNewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.AddingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNewItem += x, x => _data.AddingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratedColumns => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratedColumns += x, x => _data.AutoGeneratedColumns -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGeneratingColumn => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridAutoGeneratingColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGeneratingColumn += x, x => _data.AutoGeneratingColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginningEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridBeginningEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridBeginningEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginningEdit += x, x => _data.BeginningEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEditEnding += x, x => _data.CellEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragCompleted += x, x => _data.ColumnHeaderDragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragDelta => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragDeltaEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragDelta += x, x => _data.ColumnHeaderDragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderDragStarted => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.Primitives.DragStartedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderDragStarted += x, x => _data.ColumnHeaderDragStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridColumnReorderingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridColumnReorderingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordering += x, x => _data.ColumnReordering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingRowClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingRowClipboardContent += x, x => _data.CopyingRowClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InitializingNewItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InitializingNewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InitializingNewItem += x, x => _data.InitializingNewItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRow += x, x => _data.LoadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingRowDetails += x, x => _data.LoadingRowDetails -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreparingCellForEdit => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridPreparingCellForEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreparingCellForEdit += x, x => _data.PreparingCellForEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDetailsVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDetailsVisibilityChanged += x, x => _data.RowDetailsVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEditEnding => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEditEndingEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEditEndingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEditEnding += x, x => _data.RowEditEnding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedCellsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectedCellsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedCellsChanged += x, x => _data.SelectedCellsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridSortingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorting += x, x => _data.Sorting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRow => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRow += x, x => _data.UnloadingRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnloadingRowDetails => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridRowDetailsEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridRowDetailsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnloadingRowDetails += x, x => _data.UnloadingRowDetails -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridCellEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridCellEvents(global::System.Windows.Controls.DataGridCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridColumnEvents + { + private readonly global::System.Windows.Controls.DataGridColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridColumnEvents(global::System.Windows.Controls.DataGridColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CopyingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CopyingCellClipboardContent += x, x => _data.CopyingCellClipboardContent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PastingCellClipboardContent => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DataGridCellClipboardEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DataGridCellClipboardEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PastingCellClipboardContent += x, x => _data.PastingCellClipboardContent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridRowEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DataGridRow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridRowEvents(global::System.Windows.Controls.DataGridRow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::System.Windows.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarClosed += x, x => _data.CalendarClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalendarOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalendarOpened += x, x => _data.CalendarOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateValidationError => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.DatePickerDateValidationErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateValidationError += x, x => _data.DateValidationError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Controls.SelectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::System.Windows.Controls.Expander data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::System.Windows.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentRendered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentRendered += x, x => _data.ContentRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::System.Windows.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkCanvasEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.InkCanvas _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkCanvasEvents(global::System.Windows.Controls.InkCanvas data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActiveEditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActiveEditingModeChanged += x, x => _data.ActiveEditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultDrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultDrawingAttributesReplaced += x, x => _data.DefaultDrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeChanged += x, x => _data.EditingModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingModeInvertedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingModeInvertedChanged += x, x => _data.EditingModeInvertedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Gesture => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasGestureEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Gesture += x, x => _data.Gesture -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoved += x, x => _data.SelectionMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionMoving += x, x => _data.SelectionMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResized += x, x => _data.SelectionResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionResizing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasSelectionEditingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionResizing += x, x => _data.SelectionResizing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeCollected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeCollectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeCollected += x, x => _data.StrokeCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErased += x, x => _data.StrokeErased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeErasing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokeErasingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeErasing += x, x => _data.StrokeErasing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.InkCanvasStrokesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesReplaced += x, x => _data.StrokesReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::System.Windows.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::System.Windows.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ListBoxItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxItemEvents(global::System.Windows.Controls.ListBoxItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::System.Windows.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.ExceptionRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.MediaScriptCommandRoutedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.MediaScriptCommandRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.MenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuItemEvents(global::System.Windows.Controls.MenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuClosed += x, x => _data.SubmenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SubmenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SubmenuOpened += x, x => _data.SubmenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::System.Windows.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::System.Windows.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.ScrollChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChanged += x, x => _data.ScrollChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewItemEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.TreeViewItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewItemEvents(global::System.Windows.Controls.TreeViewItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Collapsed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Expanded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Expanded += x, x => _data.Expanded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unselected += x, x => _data.Unselected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Interop.RxHwndHostEvents + { + private readonly global::System.Windows.Controls.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Controls.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + } +} + +namespace System.Windows.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageViewEvents Events(this global::System.Windows.Controls.Primitives.DocumentPageView item) => new RxDocumentPageViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentViewerBaseEvents Events(this global::System.Windows.Controls.Primitives.DocumentViewerBase item) => new RxDocumentViewerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::System.Windows.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::System.Windows.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::System.Windows.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Controls.Primitives.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::System.Windows.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::System.Windows.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageViewEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentPageView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageViewEvents(global::System.Windows.Controls.Primitives.DocumentPageView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageConnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageConnected += x, x => _data.PageConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDisconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDisconnected += x, x => _data.PageDisconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentViewerBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.DocumentViewerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentViewerBaseEvents(global::System.Windows.Controls.Primitives.DocumentViewerBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageViewsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageViewsChanged += x, x => _data.PageViewsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::System.Windows.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::System.Windows.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.RoutedPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::System.Windows.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Controls.Primitives.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::System.Windows.Controls.RxControlEvents + { + private readonly global::System.Windows.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::System.Windows.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::System.Windows.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::System.Windows.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::System.Windows.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewEvents Events(this global::System.Windows.Data.CollectionView item) => new RxCollectionViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::System.Windows.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataSourceProviderEvents Events(this global::System.Windows.Data.DataSourceProvider item) => new RxDataSourceProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewEvents + { + private readonly global::System.Windows.Data.CollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewEvents(global::System.Windows.Data.CollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::System.Windows.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::System.Windows.Data.CollectionViewSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Filter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.FilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Filter += x, x => _data.Filter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataSourceProviderEvents + { + private readonly global::System.Windows.Data.DataSourceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataSourceProviderEvents(global::System.Windows.Data.DataSourceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } +} + +namespace System.Windows.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPageEvents Events(this global::System.Windows.Documents.DocumentPage item) => new RxDocumentPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentPaginatorEvents Events(this global::System.Windows.Documents.DocumentPaginator item) => new RxDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDocumentReferenceCollectionEvents Events(this global::System.Windows.Documents.DocumentReferenceCollection item) => new RxDocumentReferenceCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDynamicDocumentPaginatorEvents Events(this global::System.Windows.Documents.DynamicDocumentPaginator item) => new RxDynamicDocumentPaginatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::System.Windows.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPageContentEvents Events(this global::System.Windows.Documents.PageContent item) => new RxPageContentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextRangeEvents Events(this global::System.Windows.Documents.TextRange item) => new RxTextRangeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPageEvents + { + private readonly global::System.Windows.Documents.DocumentPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPageEvents(global::System.Windows.Documents.DocumentPage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageDestroyed += x, x => _data.PageDestroyed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentPaginatorEvents(global::System.Windows.Documents.DocumentPaginator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComputePageCountCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComputePageCountCompleted += x, x => _data.ComputePageCountCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageCompleted += x, x => _data.GetPageCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PagesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PagesChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PagesChanged += x, x => _data.PagesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDocumentReferenceCollectionEvents + { + private readonly global::System.Windows.Documents.DocumentReferenceCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDocumentReferenceCollectionEvents(global::System.Windows.Documents.DocumentReferenceCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDynamicDocumentPaginatorEvents : global::System.Windows.Documents.RxDocumentPaginatorEvents + { + private readonly global::System.Windows.Documents.DynamicDocumentPaginator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDynamicDocumentPaginatorEvents(global::System.Windows.Documents.DynamicDocumentPaginator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageNumberCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageNumberCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageNumberCompleted += x, x => _data.GetPageNumberCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationCompleted += x, x => _data.PaginationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaginationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.PaginationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaginationProgress += x, x => _data.PaginationProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::System.Windows.RxFrameworkContentElementEvents + { + private readonly global::System.Windows.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::System.Windows.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestNavigate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.RequestNavigateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestNavigate += x, x => _data.RequestNavigate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPageContentEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Documents.PageContent _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPageContentEvents(global::System.Windows.Documents.PageContent data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPageRootCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.GetPageRootCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPageRootCompleted += x, x => _data.GetPageRootCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextRangeEvents + { + private readonly global::System.Windows.Documents.TextRange _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextRangeEvents(global::System.Windows.Documents.TextRange data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace System.Windows.Documents.Serialization +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerializerWriterEvents Events(this global::System.Windows.Documents.Serialization.SerializerWriter item) => new RxSerializerWriterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerializerWriterEvents + { + private readonly global::System.Windows.Documents.Serialization.SerializerWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerializerWriterEvents(global::System.Windows.Documents.Serialization.SerializerWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCancelledEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCancelled += x, x => _data.WritingCancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingCompleted += x, x => _data.WritingCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingPrintTicketRequired => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingPrintTicketRequiredEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingPrintTicketRequired += x, x => _data.WritingPrintTicketRequired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WritingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Documents.Serialization.WritingProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WritingProgressChanged += x, x => _data.WritingProgressChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationContextEvents Events(this global::System.Windows.Forms.ApplicationContext item) => new RxApplicationContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoCompleteStringCollectionEvents Events(this global::System.Windows.Forms.AutoCompleteStringCollection item) => new RxAutoCompleteStringCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAxHostEvents Events(this global::System.Windows.Forms.AxHost item) => new RxAxHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingEvents Events(this global::System.Windows.Forms.Binding item) => new RxBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingContextEvents Events(this global::System.Windows.Forms.BindingContext item) => new RxBindingContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingManagerBaseEvents Events(this global::System.Windows.Forms.BindingManagerBase item) => new RxBindingManagerBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingNavigatorEvents Events(this global::System.Windows.Forms.BindingNavigator item) => new RxBindingNavigatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingsCollectionEvents Events(this global::System.Windows.Forms.BindingsCollection item) => new RxBindingsCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingSourceEvents Events(this global::System.Windows.Forms.BindingSource item) => new RxBindingSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonEvents Events(this global::System.Windows.Forms.Button item) => new RxButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::System.Windows.Forms.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckBoxEvents Events(this global::System.Windows.Forms.CheckBox item) => new RxCheckBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCheckedListBoxEvents Events(this global::System.Windows.Forms.CheckedListBox item) => new RxCheckedListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::System.Windows.Forms.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommonDialogEvents Events(this global::System.Windows.Forms.CommonDialog item) => new RxCommonDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContainerControlEvents Events(this global::System.Windows.Forms.ContainerControl item) => new RxContainerControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::System.Windows.Forms.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCurrencyManagerEvents Events(this global::System.Windows.Forms.CurrencyManager item) => new RxCurrencyManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewEvents Events(this global::System.Windows.Forms.DataGridView item) => new RxDataGridViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewCellCollectionEvents Events(this global::System.Windows.Forms.DataGridViewCellCollection item) => new RxDataGridViewCellCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnEvents Events(this global::System.Windows.Forms.DataGridViewColumn item) => new RxDataGridViewColumnEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewColumnCollectionEvents Events(this global::System.Windows.Forms.DataGridViewColumnCollection item) => new RxDataGridViewColumnCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataGridViewRowCollectionEvents Events(this global::System.Windows.Forms.DataGridViewRowCollection item) => new RxDataGridViewRowCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDateTimePickerEvents Events(this global::System.Windows.Forms.DateTimePicker item) => new RxDateTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDomainUpDownEvents Events(this global::System.Windows.Forms.DomainUpDown item) => new RxDomainUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxErrorProviderEvents Events(this global::System.Windows.Forms.ErrorProvider item) => new RxErrorProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileDialogEvents Events(this global::System.Windows.Forms.FileDialog item) => new RxFileDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderBrowserDialogEvents Events(this global::System.Windows.Forms.FolderBrowserDialog item) => new RxFolderBrowserDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFontDialogEvents Events(this global::System.Windows.Forms.FontDialog item) => new RxFontDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFormEvents Events(this global::System.Windows.Forms.Form item) => new RxFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGroupBoxEvents Events(this global::System.Windows.Forms.GroupBox item) => new RxGroupBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlDocumentEvents Events(this global::System.Windows.Forms.HtmlDocument item) => new RxHtmlDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlElementEvents Events(this global::System.Windows.Forms.HtmlElement item) => new RxHtmlElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHtmlWindowEvents Events(this global::System.Windows.Forms.HtmlWindow item) => new RxHtmlWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageListEvents Events(this global::System.Windows.Forms.ImageList item) => new RxImageListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLabelEvents Events(this global::System.Windows.Forms.Label item) => new RxLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLinkLabelEvents Events(this global::System.Windows.Forms.LinkLabel item) => new RxLinkLabelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListBoxEvents Events(this global::System.Windows.Forms.ListBox item) => new RxListBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListControlEvents Events(this global::System.Windows.Forms.ListControl item) => new RxListControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewEvents Events(this global::System.Windows.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMaskedTextBoxEvents Events(this global::System.Windows.Forms.MaskedTextBox item) => new RxMaskedTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuStripEvents Events(this global::System.Windows.Forms.MenuStrip item) => new RxMenuStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMonthCalendarEvents Events(this global::System.Windows.Forms.MonthCalendar item) => new RxMonthCalendarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotifyIconEvents Events(this global::System.Windows.Forms.NotifyIcon item) => new RxNotifyIconEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNumericUpDownEvents Events(this global::System.Windows.Forms.NumericUpDown item) => new RxNumericUpDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPanelEvents Events(this global::System.Windows.Forms.Panel item) => new RxPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPictureBoxEvents Events(this global::System.Windows.Forms.PictureBox item) => new RxPictureBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewControlEvents Events(this global::System.Windows.Forms.PrintPreviewControl item) => new RxPrintPreviewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintPreviewDialogEvents Events(this global::System.Windows.Forms.PrintPreviewDialog item) => new RxPrintPreviewDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProgressBarEvents Events(this global::System.Windows.Forms.ProgressBar item) => new RxProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertyGridEvents Events(this global::System.Windows.Forms.PropertyGrid item) => new RxPropertyGridEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::System.Windows.Forms.RadioButton item) => new RxRadioButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBoxEvents Events(this global::System.Windows.Forms.RichTextBox item) => new RxRichTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollableControlEvents Events(this global::System.Windows.Forms.ScrollableControl item) => new RxScrollableControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::System.Windows.Forms.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitContainerEvents Events(this global::System.Windows.Forms.SplitContainer item) => new RxSplitContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterEvents Events(this global::System.Windows.Forms.Splitter item) => new RxSplitterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitterPanelEvents Events(this global::System.Windows.Forms.SplitterPanel item) => new RxSplitterPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::System.Windows.Forms.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusStripEvents Events(this global::System.Windows.Forms.StatusStrip item) => new RxStatusStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabControlEvents Events(this global::System.Windows.Forms.TabControl item) => new RxTabControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTableLayoutPanelEvents Events(this global::System.Windows.Forms.TableLayoutPanel item) => new RxTableLayoutPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTabPageEvents Events(this global::System.Windows.Forms.TabPage item) => new RxTabPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::System.Windows.Forms.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxBaseEvents Events(this global::System.Windows.Forms.TextBoxBase item) => new RxTextBoxBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThreadExceptionDialogEvents Events(this global::System.Windows.Forms.ThreadExceptionDialog item) => new RxThreadExceptionDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimerEvents Events(this global::System.Windows.Forms.Timer item) => new RxTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripEvents Events(this global::System.Windows.Forms.ToolStrip item) => new RxToolStripEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripButtonEvents Events(this global::System.Windows.Forms.ToolStripButton item) => new RxToolStripButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripComboBoxEvents Events(this global::System.Windows.Forms.ToolStripComboBox item) => new RxToolStripComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContainerEvents Events(this global::System.Windows.Forms.ToolStripContainer item) => new RxToolStripContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripContentPanelEvents Events(this global::System.Windows.Forms.ToolStripContentPanel item) => new RxToolStripContentPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripControlHostEvents Events(this global::System.Windows.Forms.ToolStripControlHost item) => new RxToolStripControlHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownEvents Events(this global::System.Windows.Forms.ToolStripDropDown item) => new RxToolStripDropDownEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripDropDownItemEvents Events(this global::System.Windows.Forms.ToolStripDropDownItem item) => new RxToolStripDropDownItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripItemEvents Events(this global::System.Windows.Forms.ToolStripItem item) => new RxToolStripItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripMenuItemEvents Events(this global::System.Windows.Forms.ToolStripMenuItem item) => new RxToolStripMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripPanelEvents Events(this global::System.Windows.Forms.ToolStripPanel item) => new RxToolStripPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripProgressBarEvents Events(this global::System.Windows.Forms.ToolStripProgressBar item) => new RxToolStripProgressBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripRendererEvents Events(this global::System.Windows.Forms.ToolStripRenderer item) => new RxToolStripRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSeparatorEvents Events(this global::System.Windows.Forms.ToolStripSeparator item) => new RxToolStripSeparatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripSplitButtonEvents Events(this global::System.Windows.Forms.ToolStripSplitButton item) => new RxToolStripSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolStripTextBoxEvents Events(this global::System.Windows.Forms.ToolStripTextBox item) => new RxToolStripTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::System.Windows.Forms.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTrackBarEvents Events(this global::System.Windows.Forms.TrackBar item) => new RxTrackBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::System.Windows.Forms.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUpDownBaseEvents Events(this global::System.Windows.Forms.UpDownBase item) => new RxUpDownBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserControlEvents Events(this global::System.Windows.Forms.UserControl item) => new RxUserControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVScrollBarEvents Events(this global::System.Windows.Forms.VScrollBar item) => new RxVScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserEvents Events(this global::System.Windows.Forms.WebBrowser item) => new RxWebBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebBrowserBaseEvents Events(this global::System.Windows.Forms.WebBrowserBase item) => new RxWebBrowserBaseEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationContextEvents + { + private readonly global::System.Windows.Forms.ApplicationContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationContextEvents(global::System.Windows.Forms.ApplicationContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThreadExit += x, x => _data.ThreadExit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoCompleteStringCollectionEvents + { + private readonly global::System.Windows.Forms.AutoCompleteStringCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoCompleteStringCollectionEvents(global::System.Windows.Forms.AutoCompleteStringCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAxHostEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.AxHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAxHostEvents(global::System.Windows.Forms.AxHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingEvents + { + private readonly global::System.Windows.Forms.Binding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingEvents(global::System.Windows.Forms.Binding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Parse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Parse += x, x => _data.Parse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingContextEvents + { + private readonly global::System.Windows.Forms.BindingContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingContextEvents(global::System.Windows.Forms.BindingContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.BindingManagerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingManagerBaseEvents(global::System.Windows.Forms.BindingManagerBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingNavigatorEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.BindingNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingNavigatorEvents(global::System.Windows.Forms.BindingNavigator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RefreshItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RefreshItems += x, x => _data.RefreshItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingsCollectionEvents + { + private readonly global::System.Windows.Forms.BindingsCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingsCollectionEvents(global::System.Windows.Forms.BindingsCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanging += x, x => _data.CollectionChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingSourceEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.BindingSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingSourceEvents(global::System.Windows.Forms.BindingSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddingNew => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AddingNewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddingNew += x, x => _data.AddingNew -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingComplete += x, x => _data.BindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.BindingManagerDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.Button _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonEvents(global::System.Windows.Forms.Button data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::System.Windows.Forms.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckBoxEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.CheckBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckBoxEvents(global::System.Windows.Forms.CheckBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCheckedListBoxEvents : global::System.Windows.Forms.RxListBoxEvents + { + private readonly global::System.Windows.Forms.CheckedListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCheckedListBoxEvents(global::System.Windows.Forms.CheckedListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::System.Windows.Forms.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChangeCommitted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChangeCommitted += x, x => _data.SelectionChangeCommitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommonDialogEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.CommonDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommonDialogEvents(global::System.Windows.Forms.CommonDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContainerControlEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ContainerControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContainerControlEvents(global::System.Windows.Forms.ContainerControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::System.Windows.Forms.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClientSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClientSizeChanged += x, x => _data.ClientSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedAfterParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedAfterParent += x, x => _data.DpiChangedAfterParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChangedBeforeParent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChangedBeforeParent += x, x => _data.DpiChangedBeforeParent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleCreated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleCreated += x, x => _data.HandleCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HandleDestroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HandleDestroyed += x, x => _data.HandleDestroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InvalidateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Move => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Move += x, x => _data.Move -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ParentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ParentChanged += x, x => _data.ParentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PreviewKeyDownEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SystemColorsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SystemColorsChanged += x, x => _data.SystemColorsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCurrencyManagerEvents : global::System.Windows.Forms.RxBindingManagerBaseEvents + { + private readonly global::System.Windows.Forms.CurrencyManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCurrencyManagerEvents(global::System.Windows.Forms.CurrencyManager data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChanged += x, x => _data.ItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ListChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListChanged += x, x => _data.ListChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MetaDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MetaDataChanged += x, x => _data.MetaDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DataGridView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewEvents(global::System.Windows.Forms.DataGridView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToAddRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToAddRowsChanged += x, x => _data.AllowUserToAddRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToDeleteRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToDeleteRowsChanged += x, x => _data.AllowUserToDeleteRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToOrderColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToOrderColumnsChanged += x, x => _data.AllowUserToOrderColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeColumnsChanged += x, x => _data.AllowUserToResizeColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllowUserToResizeRowsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllowUserToResizeRowsChanged += x, x => _data.AllowUserToResizeRowsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AlternatingRowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AlternatingRowsDefaultCellStyleChanged += x, x => _data.AlternatingRowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoGenerateColumnsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoGenerateColumnsChanged += x, x => _data.AutoGenerateColumnsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnModeChanged += x, x => _data.AutoSizeColumnModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeColumnsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeColumnsModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeColumnsModeChanged += x, x => _data.AutoSizeColumnsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeRowsModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeRowsModeChanged += x, x => _data.AutoSizeRowsModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundColorChanged += x, x => _data.BackgroundColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelRowEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelRowEdit += x, x => _data.CancelRowEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBeginEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBeginEdit += x, x => _data.CellBeginEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellBorderStyleChanged += x, x => _data.CellBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClick += x, x => _data.CellClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentClick += x, x => _data.CellContentClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContentDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContentDoubleClick += x, x => _data.CellContentDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripChanged += x, x => _data.CellContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellContextMenuStripNeeded += x, x => _data.CellContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClick += x, x => _data.CellDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEndEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEndEdit += x, x => _data.CellEndEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellEnter += x, x => _data.CellEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextChanged += x, x => _data.CellErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellErrorTextNeeded += x, x => _data.CellErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellFormatting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellFormattingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellFormatting += x, x => _data.CellFormatting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellLeave += x, x => _data.CellLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseClick += x, x => _data.CellMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDoubleClick += x, x => _data.CellMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseDown += x, x => _data.CellMouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseEnter += x, x => _data.CellMouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseLeave += x, x => _data.CellMouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseMove += x, x => _data.CellMouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellMouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellMouseUp += x, x => _data.CellMouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPainting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellPaintingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPainting += x, x => _data.CellPainting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellParsing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellParsingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellParsing += x, x => _data.CellParsing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStateChanged += x, x => _data.CellStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleChanged += x, x => _data.CellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellStyleContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellStyleContentChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellStyleContentChanged += x, x => _data.CellStyleContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextChanged += x, x => _data.CellToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellToolTipTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellToolTipTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellToolTipTextNeeded += x, x => _data.CellToolTipTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidated += x, x => _data.CellValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValidatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValidating += x, x => _data.CellValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueChanged += x, x => _data.CellValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValueNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValueNeeded += x, x => _data.CellValueNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellValuePushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellValueEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellValuePushed += x, x => _data.CellValuePushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnAdded += x, x => _data.ColumnAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnContextMenuStripChanged += x, x => _data.ColumnContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDataPropertyNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDataPropertyNameChanged += x, x => _data.ColumnDataPropertyNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDefaultCellStyleChanged += x, x => _data.ColumnDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDisplayIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDisplayIndexChanged += x, x => _data.ColumnDisplayIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerDoubleClick += x, x => _data.ColumnDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDividerWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDividerWidthChanged += x, x => _data.ColumnDividerWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderCellChanged += x, x => _data.ColumnHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseClick += x, x => _data.ColumnHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeaderMouseDoubleClick += x, x => _data.ColumnHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersBorderStyleChanged += x, x => _data.ColumnHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersDefaultCellStyleChanged += x, x => _data.ColumnHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightChanged += x, x => _data.ColumnHeadersHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnHeadersHeightSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnHeadersHeightSizeModeChanged += x, x => _data.ColumnHeadersHeightSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnMinimumWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnMinimumWidthChanged += x, x => _data.ColumnMinimumWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnNameChanged += x, x => _data.ColumnNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnRemoved += x, x => _data.ColumnRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnSortModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnSortModeChanged += x, x => _data.ColumnSortModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnStateChanged += x, x => _data.ColumnStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnToolTipTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnToolTipTextChanged += x, x => _data.ColumnToolTipTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellChanged += x, x => _data.CurrentCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentCellDirtyStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentCellDirtyStateChanged += x, x => _data.CurrentCellDirtyStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataBindingComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewBindingCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataBindingComplete += x, x => _data.DataBindingComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataError => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewDataErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataError += x, x => _data.DataError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataMemberChanged += x, x => _data.DataMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultCellStyleChanged += x, x => _data.DefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultValuesNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultValuesNeeded += x, x => _data.DefaultValuesNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingControlShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewEditingControlShowingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingControlShowing += x, x => _data.EditingControlShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditModeChanged += x, x => _data.EditModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GridColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GridColorChanged += x, x => _data.GridColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultiSelectChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultiSelectChanged += x, x => _data.MultiSelectChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewRowNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewRowNeeded += x, x => _data.NewRowNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripChanged += x, x => _data.RowContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowContextMenuStripNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowContextMenuStripNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowContextMenuStripNeeded += x, x => _data.RowContextMenuStripNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDefaultCellStyleChanged += x, x => _data.RowDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDirtyStateNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QuestionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDirtyStateNeeded += x, x => _data.RowDirtyStateNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowDividerDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerDoubleClick += x, x => _data.RowDividerDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowDividerHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowDividerHeightChanged += x, x => _data.RowDividerHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowEnter += x, x => _data.RowEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextChanged += x, x => _data.RowErrorTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowErrorTextNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowErrorTextNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowErrorTextNeeded += x, x => _data.RowErrorTextNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderCellChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderCellChanged += x, x => _data.RowHeaderCellChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseClick += x, x => _data.RowHeaderMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeaderMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellMouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeaderMouseDoubleClick += x, x => _data.RowHeaderMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersBorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersBorderStyleChanged += x, x => _data.RowHeadersBorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersDefaultCellStyleChanged += x, x => _data.RowHeadersDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthChanged += x, x => _data.RowHeadersWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeadersWidthSizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewAutoSizeModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeadersWidthSizeModeChanged += x, x => _data.RowHeadersWidthSizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightChanged += x, x => _data.RowHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoNeededEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoNeeded += x, x => _data.RowHeightInfoNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowHeightInfoPushed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowHeightInfoPushedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowHeightInfoPushed += x, x => _data.RowHeightInfoPushed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowLeave += x, x => _data.RowLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowMinimumHeightChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowMinimumHeightChanged += x, x => _data.RowMinimumHeightChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPostPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPostPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPostPaint += x, x => _data.RowPostPaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowPrePaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowPrePaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowPrePaint += x, x => _data.RowPrePaint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsAddedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsAdded += x, x => _data.RowsAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDefaultCellStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDefaultCellStyleChanged += x, x => _data.RowsDefaultCellStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsRemoved += x, x => _data.RowsRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowStateChanged += x, x => _data.RowStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowUnshared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowUnshared += x, x => _data.RowUnshared -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidated += x, x => _data.RowValidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowValidating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewCellCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowValidating += x, x => _data.RowValidating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SortCompare => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewSortCompareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SortCompare += x, x => _data.SortCompare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Sorted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Sorted += x, x => _data.Sorted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserAddedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserAddedRow += x, x => _data.UserAddedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletedRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletedRow += x, x => _data.UserDeletedRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDeletingRow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DataGridViewRowCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDeletingRow += x, x => _data.UserDeletingRow -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewCellCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewCellCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewCellCollectionEvents(global::System.Windows.Forms.DataGridViewCellCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumn _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnEvents(global::System.Windows.Forms.DataGridViewColumn data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewColumnCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewColumnCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewColumnCollectionEvents(global::System.Windows.Forms.DataGridViewColumnCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataGridViewRowCollectionEvents + { + private readonly global::System.Windows.Forms.DataGridViewRowCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataGridViewRowCollectionEvents(global::System.Windows.Forms.DataGridViewRowCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CollectionChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDateTimePickerEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.DateTimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDateTimePickerEvents(global::System.Windows.Forms.DateTimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseUp += x, x => _data.CloseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDomainUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.DomainUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDomainUpDownEvents(global::System.Windows.Forms.DomainUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxErrorProviderEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ErrorProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxErrorProviderEvents(global::System.Windows.Forms.ErrorProvider data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FileDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileDialogEvents(global::System.Windows.Forms.FileDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileOk => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileOk += x, x => _data.FileOk -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderBrowserDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FolderBrowserDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderBrowserDialogEvents(global::System.Windows.Forms.FolderBrowserDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequest => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpRequest += x, x => _data.HelpRequest -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFontDialogEvents : global::System.Windows.Forms.RxCommonDialogEvents + { + private readonly global::System.Windows.Forms.FontDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFontDialogEvents(global::System.Windows.Forms.FontDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Apply => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Apply += x, x => _data.Apply -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFormEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.Form _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFormEvents(global::System.Windows.Forms.Form data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivate += x, x => _data.Deactivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosed += x, x => _data.FormClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormClosing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.FormClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormClosing += x, x => _data.FormClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HelpButtonClicked += x, x => _data.HelpButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.InputLanguageChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximizedBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximizedBoundsChanged += x, x => _data.MaximizedBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MdiChildActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MdiChildActivate += x, x => _data.MdiChildActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuComplete += x, x => _data.MenuComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuStart => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuStart += x, x => _data.MenuStart -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeBegin += x, x => _data.ResizeBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResizeEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResizeEnd += x, x => _data.ResizeEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Shown += x, x => _data.Shown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGroupBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.GroupBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGroupBoxEvents(global::System.Windows.Forms.GroupBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlDocumentEvents + { + private readonly global::System.Windows.Forms.HtmlDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlDocumentEvents(global::System.Windows.Forms.HtmlDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuShowing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuShowing += x, x => _data.ContextMenuShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stop += x, x => _data.Stop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlElementEvents + { + private readonly global::System.Windows.Forms.HtmlElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlElementEvents(global::System.Windows.Forms.HtmlElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drag += x, x => _data.Drag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnd += x, x => _data.DragEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Focusing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Focusing += x, x => _data.Focusing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LosingFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseOver += x, x => _data.MouseOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHtmlWindowEvents + { + private readonly global::System.Windows.Forms.HtmlWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHtmlWindowEvents(global::System.Windows.Forms.HtmlWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Error => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Resize += x, x => _data.Resize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HtmlElementEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unload += x, x => _data.Unload -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageListEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ImageList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageListEvents(global::System.Windows.Forms.ImageList data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecreateHandle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RecreateHandle += x, x => _data.RecreateHandle -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLabelEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Label _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLabelEvents(global::System.Windows.Forms.Label data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLinkLabelEvents : global::System.Windows.Forms.RxLabelEvents + { + private readonly global::System.Windows.Forms.LinkLabel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLinkLabelEvents(global::System.Windows.Forms.LinkLabel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkLabelLinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListBoxEvents : global::System.Windows.Forms.RxListControlEvents + { + private readonly global::System.Windows.Forms.ListBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListBoxEvents(global::System.Windows.Forms.ListBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MeasureItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MeasureItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MeasureItem += x, x => _data.MeasureItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListControlEvents(global::System.Windows.Forms.ListControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataSourceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataSourceChanged += x, x => _data.DataSourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayMemberChanged += x, x => _data.DisplayMemberChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Format => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListControlConvertEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Format += x, x => _data.Format -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatInfoChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatInfoChanged += x, x => _data.FormatInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormatStringChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormatStringChanged += x, x => _data.FormatStringChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FormattingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FormattingEnabledChanged += x, x => _data.FormattingEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedValueChanged += x, x => _data.SelectedValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueMemberChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueMemberChanged += x, x => _data.ValueMemberChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ListView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewEvents(global::System.Windows.Forms.ListView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CacheVirtualItems => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.CacheVirtualItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CacheVirtualItems += x, x => _data.CacheVirtualItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnClick += x, x => _data.ColumnClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnReorderedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnReordered += x, x => _data.ColumnReordered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanged += x, x => _data.ColumnWidthChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnWidthChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ColumnWidthChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnWidthChanging += x, x => _data.ColumnWidthChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawColumnHeader => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewColumnHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawColumnHeader += x, x => _data.DrawColumnHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawSubItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawListViewSubItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawSubItem += x, x => _data.DrawSubItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemActivate += x, x => _data.ItemActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemCheck += x, x => _data.ItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemChecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemCheckedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemChecked += x, x => _data.ItemChecked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemMouseHover += x, x => _data.ItemMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewItemSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelectionChanged += x, x => _data.ItemSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrieveVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.RetrieveVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrieveVirtualItem += x, x => _data.RetrieveVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForVirtualItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SearchForVirtualItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForVirtualItem += x, x => _data.SearchForVirtualItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VirtualItemsSelectionRangeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ListViewVirtualItemsSelectionRangeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VirtualItemsSelectionRangeChanged += x, x => _data.VirtualItemsSelectionRangeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMaskedTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.MaskedTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMaskedTextBoxEvents(global::System.Windows.Forms.MaskedTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsOverwriteModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsOverwriteModeChanged += x, x => _data.IsOverwriteModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskChanged += x, x => _data.MaskChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaskInputRejected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MaskInputRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaskInputRejected += x, x => _data.MaskInputRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TypeValidationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TypeValidationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TypeValidationCompleted += x, x => _data.TypeValidationCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.MenuStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuStripEvents(global::System.Windows.Forms.MenuStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuActivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuActivate += x, x => _data.MenuActivate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuDeactivate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MenuDeactivate += x, x => _data.MenuDeactivate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMonthCalendarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.MonthCalendar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMonthCalendarEvents(global::System.Windows.Forms.MonthCalendar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DateRangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotifyIconEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.NotifyIcon _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotifyIconEvents(global::System.Windows.Forms.NotifyIcon data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClicked += x, x => _data.BalloonTipClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipClosed += x, x => _data.BalloonTipClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BalloonTipShown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BalloonTipShown += x, x => _data.BalloonTipShown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNumericUpDownEvents : global::System.Windows.Forms.RxUpDownBaseEvents + { + private readonly global::System.Windows.Forms.NumericUpDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNumericUpDownEvents(global::System.Windows.Forms.NumericUpDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPanelEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.Panel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPanelEvents(global::System.Windows.Forms.Panel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPictureBoxEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PictureBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPictureBoxEvents(global::System.Windows.Forms.PictureBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.ProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadProgressChanged += x, x => _data.LoadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeModeChanged += x, x => _data.SizeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.PrintPreviewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewControlEvents(global::System.Windows.Forms.PrintPreviewControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartPageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartPageChanged += x, x => _data.StartPageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintPreviewDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.PrintPreviewDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintPreviewDialogEvents(global::System.Windows.Forms.PrintPreviewDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarginChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarginChanged += x, x => _data.MarginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MaximumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MaximumSizeChanged += x, x => _data.MaximumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MinimumSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MinimumSizeChanged += x, x => _data.MinimumSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProgressBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProgressBarEvents(global::System.Windows.Forms.ProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertyGridEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.PropertyGrid _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertyGridEvents(global::System.Windows.Forms.PropertyGrid data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertySortChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertySortChanged += x, x => _data.PropertySortChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyTabChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyTabChanged += x, x => _data.PropertyTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object s, global::System.Windows.Forms.PropertyValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyValueChanged += x, x => _data.PropertyValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedGridItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SelectedGridItemChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedGridItemChanged += x, x => _data.SelectedGridItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedObjectsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedObjectsChanged += x, x => _data.SelectedObjectsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::System.Windows.Forms.RxButtonBaseEvents + { + private readonly global::System.Windows.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::System.Windows.Forms.RadioButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AppearanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AppearanceChanged += x, x => _data.AppearanceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.RichTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBoxEvents(global::System.Windows.Forms.RichTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContentsResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ContentsResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContentsResized += x, x => _data.ContentsResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HScroll += x, x => _data.HScroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeChange += x, x => _data.ImeChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LinkClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LinkClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LinkClicked += x, x => _data.LinkClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Protected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Protected += x, x => _data.Protected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VScroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VScroll += x, x => _data.VScroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollableControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollableControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollableControlEvents(global::System.Windows.Forms.ScrollableControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::System.Windows.Forms.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.SplitContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitContainerEvents(global::System.Windows.Forms.SplitContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.Splitter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterEvents(global::System.Windows.Forms.Splitter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoved += x, x => _data.SplitterMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SplitterMoving => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.SplitterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SplitterMoving += x, x => _data.SplitterMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitterPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.SplitterPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitterPanelEvents(global::System.Windows.Forms.SplitterPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::System.Windows.Forms.StatusBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarDrawItemEventArgs sbdevent) => eventHandler(sbdevent); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PanelClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.StatusBarPanelClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PanelClick += x, x => _data.PanelClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusStripEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.StatusStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusStripEvents(global::System.Windows.Forms.StatusStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabControlEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TabControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabControlEvents(global::System.Windows.Forms.TabControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselected += x, x => _data.Deselected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deselecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deselecting += x, x => _data.Deselecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawItem += x, x => _data.DrawItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selected += x, x => _data.Selected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Selecting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TabControlCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Selecting += x, x => _data.Selecting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTableLayoutPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TableLayoutPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTableLayoutPanelEvents(global::System.Windows.Forms.TableLayoutPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellPaint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TableLayoutCellPaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellPaint += x, x => _data.CellPaint -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTabPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.TabPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTabPageEvents(global::System.Windows.Forms.TabPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::System.Windows.Forms.RxTextBoxBaseEvents + { + private readonly global::System.Windows.Forms.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::System.Windows.Forms.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextAlignChanged += x, x => _data.TextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TextBoxBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxBaseEvents(global::System.Windows.Forms.TextBoxBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThreadExceptionDialogEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.ThreadExceptionDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThreadExceptionDialogEvents(global::System.Windows.Forms.ThreadExceptionDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimerEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.Timer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimerEvents(global::System.Windows.Forms.Timer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripEvents : global::System.Windows.Forms.RxScrollableControlEvents + { + private readonly global::System.Windows.Forms.ToolStrip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripEvents(global::System.Windows.Forms.ToolStrip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginDrag += x, x => _data.BeginDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlAdded += x, x => _data.ControlAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ControlRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ControlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ControlRemoved += x, x => _data.ControlRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndDrag += x, x => _data.EndDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutCompleted += x, x => _data.LayoutCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LayoutStyleChanged += x, x => _data.LayoutStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaintGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaintGrip += x, x => _data.PaintGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripButtonEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripButtonEvents(global::System.Windows.Forms.ToolStripButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripComboBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripComboBoxEvents(global::System.Windows.Forms.ToolStripComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDown += x, x => _data.DropDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownStyleChanged += x, x => _data.DropDownStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextUpdate += x, x => _data.TextUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContainerEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContainerEvents(global::System.Windows.Forms.ToolStripContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripContentPanelEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.ToolStripContentPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripContentPanelEvents(global::System.Windows.Forms.ToolStripContentPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CausesValidationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CausesValidationChanged += x, x => _data.CausesValidationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripControlHostEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripControlHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripControlHostEvents(global::System.Windows.Forms.ToolStripControlHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownEvents : global::System.Windows.Forms.RxToolStripEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDown _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownEvents(global::System.Windows.Forms.ToolStripDropDown data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripDropDownClosingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuStripChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuStripChanged += x, x => _data.ContextMenuStripChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DockChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DockChanged += x, x => _data.DockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripDropDownItemEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripDropDownItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripDropDownItemEvents(global::System.Windows.Forms.ToolStripDropDownItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownItemClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownItemClicked += x, x => _data.DropDownItemClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpening += x, x => _data.DropDownOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripItemEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolStripItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripItemEvents(global::System.Windows.Forms.ToolStripItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibleChanged += x, x => _data.VisibleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripMenuItemEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripMenuItemEvents(global::System.Windows.Forms.ToolStripMenuItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckStateChanged += x, x => _data.CheckStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripPanelEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.ToolStripPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripPanelEvents(global::System.Windows.Forms.ToolStripPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RendererChanged += x, x => _data.RendererChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabIndexChanged += x, x => _data.TabIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TabStopChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TabStopChanged += x, x => _data.TabStopChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripProgressBarEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripProgressBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripProgressBarEvents(global::System.Windows.Forms.ToolStripProgressBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OwnerChanged += x, x => _data.OwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validated += x, x => _data.Validated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Validating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Validating += x, x => _data.Validating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripRendererEvents + { + private readonly global::System.Windows.Forms.ToolStripRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripRendererEvents(global::System.Windows.Forms.ToolStripRenderer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderArrow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripArrowRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderArrow += x, x => _data.RenderArrow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderButtonBackground += x, x => _data.RenderButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderDropDownButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderDropDownButtonBackground += x, x => _data.RenderDropDownButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripGripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderGrip += x, x => _data.RenderGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderImageMargin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderImageMargin += x, x => _data.RenderImageMargin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemBackground += x, x => _data.RenderItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemCheck += x, x => _data.RenderItemCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemImage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemImageRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemImage += x, x => _data.RenderItemImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderItemText => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemTextRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderItemText += x, x => _data.RenderItemText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderLabelBackground += x, x => _data.RenderLabelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderMenuItemBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderMenuItemBackground += x, x => _data.RenderMenuItemBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderOverflowButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderOverflowButtonBackground += x, x => _data.RenderOverflowButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSeparator => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripSeparatorRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSeparator += x, x => _data.RenderSeparator -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderSplitButtonBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderSplitButtonBackground += x, x => _data.RenderSplitButtonBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderStatusStripSizingGrip => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderStatusStripSizingGrip += x, x => _data.RenderStatusStripSizingGrip -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBackground += x, x => _data.RenderToolStripBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripBorder => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripBorder += x, x => _data.RenderToolStripBorder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripContentPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripContentPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripContentPanelBackground += x, x => _data.RenderToolStripContentPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripPanelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripPanelRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripPanelBackground += x, x => _data.RenderToolStripPanelBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RenderToolStripStatusLabelBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ToolStripItemRenderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RenderToolStripStatusLabelBackground += x, x => _data.RenderToolStripStatusLabelBackground -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSeparatorEvents : global::System.Windows.Forms.RxToolStripItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSeparator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSeparatorEvents(global::System.Windows.Forms.ToolStripSeparator data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisplayStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisplayStyleChanged += x, x => _data.DisplayStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripSplitButtonEvents : global::System.Windows.Forms.RxToolStripDropDownItemEvents + { + private readonly global::System.Windows.Forms.ToolStripSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripSplitButtonEvents(global::System.Windows.Forms.ToolStripSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonClick += x, x => _data.ButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ButtonDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ButtonDoubleClick += x, x => _data.ButtonDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DefaultItemChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DefaultItemChanged += x, x => _data.DefaultItemChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolStripTextBoxEvents : global::System.Windows.Forms.RxToolStripControlHostEvents + { + private readonly global::System.Windows.Forms.ToolStripTextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolStripTextBoxEvents(global::System.Windows.Forms.ToolStripTextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptsTabChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptsTabChanged += x, x => _data.AcceptsTabChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BorderStyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BorderStyleChanged += x, x => _data.BorderStyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HideSelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HideSelectionChanged += x, x => _data.HideSelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedChanged += x, x => _data.ModifiedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MultilineChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MultilineChanged += x, x => _data.MultilineChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadOnlyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadOnlyChanged += x, x => _data.ReadOnlyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextBoxTextAlignChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextBoxTextAlignChanged += x, x => _data.TextBoxTextAlignChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::System.ComponentModel.RxComponentEvents + { + private readonly global::System.Windows.Forms.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::System.Windows.Forms.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Draw => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawToolTipEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Draw += x, x => _data.Draw -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Popup => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PopupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Popup += x, x => _data.Popup -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTrackBarEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TrackBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTrackBarEvents(global::System.Windows.Forms.TrackBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::System.Windows.Forms.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCheck += x, x => _data.AfterCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterCollapse += x, x => _data.AfterCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterExpand += x, x => _data.AfterExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterLabelEdit += x, x => _data.AfterLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AfterSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AfterSelect += x, x => _data.AfterSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCheck => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCheck += x, x => _data.BeforeCheck -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeCollapse += x, x => _data.BeforeCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeExpand += x, x => _data.BeforeExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeLabelEdit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.NodeLabelEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeLabelEdit += x, x => _data.BeforeLabelEdit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeforeSelect => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeViewCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeforeSelect += x, x => _data.BeforeSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawNode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DrawTreeNodeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawNode += x, x => _data.DrawNode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.ItemDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemDrag += x, x => _data.ItemDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseClick += x, x => _data.NodeMouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseDoubleClick += x, x => _data.NodeMouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NodeMouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.TreeNodeMouseHoverEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NodeMouseHover += x, x => _data.NodeMouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftLayoutChanged += x, x => _data.RightToLeftLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUpDownBaseEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UpDownBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUpDownBaseEvents(global::System.Windows.Forms.UpDownBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserControlEvents : global::System.Windows.Forms.RxContainerControlEvents + { + private readonly global::System.Windows.Forms.UserControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserControlEvents(global::System.Windows.Forms.UserControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoValidateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoValidateChanged += x, x => _data.AutoValidateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Load => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Load += x, x => _data.Load -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVScrollBarEvents : global::System.Windows.Forms.RxScrollBarEvents + { + private readonly global::System.Windows.Forms.VScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVScrollBarEvents(global::System.Windows.Forms.VScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserEvents : global::System.Windows.Forms.RxWebBrowserBaseEvents + { + private readonly global::System.Windows.Forms.WebBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserEvents(global::System.Windows.Forms.WebBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoBackChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoBackChanged += x, x => _data.CanGoBackChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanGoForwardChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanGoForwardChanged += x, x => _data.CanGoForwardChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserDocumentCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentCompleted += x, x => _data.DocumentCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DocumentTitleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DocumentTitleChanged += x, x => _data.DocumentTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncryptionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncryptionLevelChanged += x, x => _data.EncryptionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FileDownload => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FileDownload += x, x => _data.FileDownload -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserNavigatingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewWindow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.CancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewWindow += x, x => _data.NewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaddingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaddingChanged += x, x => _data.PaddingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.WebBrowserProgressChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StatusTextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StatusTextChanged += x, x => _data.StatusTextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebBrowserBaseEvents : global::System.Windows.Forms.RxControlEvents + { + private readonly global::System.Windows.Forms.WebBrowserBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebBrowserBaseEvents(global::System.Windows.Forms.WebBrowserBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackColorChanged += x, x => _data.BackColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageChanged += x, x => _data.BackgroundImageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundImageLayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundImageLayoutChanged += x, x => _data.BackgroundImageLayoutChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangeUICues => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.UICuesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangeUICues += x, x => _data.ChangeUICues -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDrop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDrop += x, x => _data.DragDrop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Enter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Enter += x, x => _data.Enter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FontChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FontChanged += x, x => _data.FontChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ForeColorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ForeColorChanged += x, x => _data.ForeColorChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GiveFeedback => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.GiveFeedbackEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GiveFeedback += x, x => _data.GiveFeedback -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HelpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.HelpEventArgs hlpevent) => eventHandler(hlpevent); + return Handler; + }, x => _data.HelpRequested += x, x => _data.HelpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImeModeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImeModeChanged += x, x => _data.ImeModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyPressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.KeyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Layout => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.LayoutEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Layout += x, x => _data.Layout -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Leave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Leave += x, x => _data.Leave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseCaptureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseCaptureChanged += x, x => _data.MouseCaptureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseClick += x, x => _data.MouseClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDoubleClick += x, x => _data.MouseDoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDown += x, x => _data.MouseDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseEnter += x, x => _data.MouseEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseHover => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseHover += x, x => _data.MouseHover -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseLeave += x, x => _data.MouseLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseMove += x, x => _data.MouseMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseUp += x, x => _data.MouseUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseWheel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.MouseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseWheel += x, x => _data.MouseWheel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.PaintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paint += x, x => _data.Paint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryAccessibilityHelp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryAccessibilityHelpEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryAccessibilityHelp += x, x => _data.QueryAccessibilityHelp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable QueryContinueDrag => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Forms.QueryContinueDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.QueryContinueDrag += x, x => _data.QueryContinueDrag -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightToLeftChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightToLeftChanged += x, x => _data.RightToLeftChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StyleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace System.Windows.Forms.ComponentModel.Com2Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIComPropertyBrowserEvents Events(this global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser item) => new RxIComPropertyBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIComPropertyBrowserEvents + { + private readonly global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIComPropertyBrowserEvents(global::System.Windows.Forms.ComponentModel.Com2Interop.IComPropertyBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ComComponentNameChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.Design.ComponentRenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ComComponentNameChanged += x, x => _data.ComComponentNameChanged -= x); + } +} + +namespace System.Windows.Forms.Design +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorFormEvents Events(this global::System.Windows.Forms.Design.ComponentEditorForm item) => new RxComponentEditorFormEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComponentEditorPageEvents Events(this global::System.Windows.Forms.Design.ComponentEditorPage item) => new RxComponentEditorPageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorFormEvents : global::System.Windows.Forms.RxFormEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorForm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorFormEvents(global::System.Windows.Forms.Design.ComponentEditorForm data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComponentEditorPageEvents : global::System.Windows.Forms.RxPanelEvents + { + private readonly global::System.Windows.Forms.Design.ComponentEditorPage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComponentEditorPageEvents(global::System.Windows.Forms.Design.ComponentEditorPage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoSizeChanged += x, x => _data.AutoSizeChanged -= x); + } +} + +namespace System.Windows.Ink +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawingAttributesEvents Events(this global::System.Windows.Ink.DrawingAttributes item) => new RxDrawingAttributesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalLassoHitTesterEvents Events(this global::System.Windows.Ink.IncrementalLassoHitTester item) => new RxIncrementalLassoHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIncrementalStrokeHitTesterEvents Events(this global::System.Windows.Ink.IncrementalStrokeHitTester item) => new RxIncrementalStrokeHitTesterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeEvents Events(this global::System.Windows.Ink.Stroke item) => new RxStrokeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStrokeCollectionEvents Events(this global::System.Windows.Ink.StrokeCollection item) => new RxStrokeCollectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawingAttributesEvents + { + private readonly global::System.Windows.Ink.DrawingAttributes _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawingAttributesEvents(global::System.Windows.Ink.DrawingAttributes data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AttributeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AttributeChanged += x, x => _data.AttributeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalLassoHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalLassoHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalLassoHitTesterEvents(global::System.Windows.Ink.IncrementalLassoHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.LassoSelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIncrementalStrokeHitTesterEvents + { + private readonly global::System.Windows.Ink.IncrementalStrokeHitTester _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIncrementalStrokeHitTesterEvents(global::System.Windows.Ink.IncrementalStrokeHitTester data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokeHit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeHitEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokeHit += x, x => _data.StrokeHit -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeEvents + { + private readonly global::System.Windows.Ink.Stroke _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeEvents(global::System.Windows.Ink.Stroke data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesChanged += x, x => _data.DrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawingAttributesReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.DrawingAttributesReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawingAttributesReplaced += x, x => _data.DrawingAttributesReplaced -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Invalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Invalidated += x, x => _data.Invalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsChanged += x, x => _data.StylusPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StylusPointsReplaced => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StylusPointsReplacedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StylusPointsReplaced += x, x => _data.StylusPointsReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStrokeCollectionEvents + { + private readonly global::System.Windows.Ink.StrokeCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStrokeCollectionEvents(global::System.Windows.Ink.StrokeCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyDataChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.PropertyDataChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyDataChanged += x, x => _data.PropertyDataChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StrokesChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Ink.StrokeCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StrokesChanged += x, x => _data.StrokesChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBindingEvents Events(this global::System.Windows.Input.CommandBinding item) => new RxCommandBindingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIManipulatorEvents Events(this global::System.Windows.Input.IManipulator item) => new RxIManipulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputLanguageManagerEvents Events(this global::System.Windows.Input.InputLanguageManager item) => new RxInputLanguageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputManagerEvents Events(this global::System.Windows.Input.InputManager item) => new RxInputManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputMethodEvents Events(this global::System.Windows.Input.InputMethod item) => new RxInputMethodEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRoutedCommandEvents Events(this global::System.Windows.Input.RoutedCommand item) => new RxRoutedCommandEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStylusPointCollectionEvents Events(this global::System.Windows.Input.StylusPointCollection item) => new RxStylusPointCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTouchDeviceEvents Events(this global::System.Windows.Input.TouchDevice item) => new RxTouchDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBindingEvents + { + private readonly global::System.Windows.Input.CommandBinding _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBindingEvents(global::System.Windows.Input.CommandBinding data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecute += x, x => _data.CanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Executed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Executed += x, x => _data.Executed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewCanExecute => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.CanExecuteRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewCanExecute += x, x => _data.PreviewCanExecute -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewExecuted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ExecutedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewExecuted += x, x => _data.PreviewExecuted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIManipulatorEvents + { + private readonly global::System.Windows.Input.IManipulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIManipulatorEvents(global::System.Windows.Input.IManipulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputLanguageManagerEvents + { + private readonly global::System.Windows.Input.InputLanguageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputLanguageManagerEvents(global::System.Windows.Input.InputLanguageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputLanguageChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputLanguageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputLanguageChanging += x, x => _data.InputLanguageChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputManagerEvents + { + private readonly global::System.Windows.Input.InputManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputManagerEvents(global::System.Windows.Input.InputManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnterMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnterMenuMode += x, x => _data.EnterMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HitTestInvalidatedAsync => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HitTestInvalidatedAsync += x, x => _data.HitTestInvalidatedAsync -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeaveMenuMode => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeaveMenuMode += x, x => _data.LeaveMenuMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostNotifyInput += x, x => _data.PostNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PostProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.ProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PostProcessInput += x, x => _data.PostProcessInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreNotifyInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.NotifyInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreNotifyInput += x, x => _data.PreNotifyInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreProcessInput => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.PreProcessInputEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreProcessInput += x, x => _data.PreProcessInput -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputMethodEvents + { + private readonly global::System.Windows.Input.InputMethod _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputMethodEvents(global::System.Windows.Input.InputMethod data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.InputMethodStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRoutedCommandEvents + { + private readonly global::System.Windows.Input.RoutedCommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRoutedCommandEvents(global::System.Windows.Input.RoutedCommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStylusPointCollectionEvents + { + private readonly global::System.Windows.Input.StylusPointCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStylusPointCollectionEvents(global::System.Windows.Input.StylusPointCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTouchDeviceEvents + { + private readonly global::System.Windows.Input.TouchDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTouchDeviceEvents(global::System.Windows.Input.TouchDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Deactivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Deactivated += x, x => _data.Deactivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Updated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxD3DImageEvents Events(this global::System.Windows.Interop.D3DImage item) => new RxD3DImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndHostEvents Events(this global::System.Windows.Interop.HwndHost item) => new RxHwndHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHwndSourceEvents Events(this global::System.Windows.Interop.HwndSource item) => new RxHwndSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxD3DImageEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Interop.D3DImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxD3DImageEvents(global::System.Windows.Interop.D3DImage data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsFrontBufferAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsFrontBufferAvailableChanged += x, x => _data.IsFrontBufferAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndHostEvents : global::System.Windows.RxFrameworkElementEvents + { + private readonly global::System.Windows.Interop.HwndHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndHostEvents(global::System.Windows.Interop.HwndHost data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.DpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHwndSourceEvents : global::System.Windows.RxPresentationSourceEvents + { + private readonly global::System.Windows.Interop.HwndSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHwndSourceEvents(global::System.Windows.Interop.HwndSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AutoResized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.AutoResizedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AutoResized += x, x => _data.AutoResized -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disposed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disposed += x, x => _data.Disposed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.HwndDpiChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeToContentChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeToContentChanged += x, x => _data.SizeToContentChanged -= x); + } +} + +namespace System.Windows.Markup +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlReaderEvents Events(this global::System.Windows.Markup.XamlReader item) => new RxXamlReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlReaderEvents + { + private readonly global::System.Windows.Markup.XamlReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlReaderEvents(global::System.Windows.Markup.XamlReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.AsyncCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace System.Windows.Markup.Localizer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBamlLocalizerEvents Events(this global::System.Windows.Markup.Localizer.BamlLocalizer item) => new RxBamlLocalizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBamlLocalizerEvents + { + private readonly global::System.Windows.Markup.Localizer.BamlLocalizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBamlLocalizerEvents(global::System.Windows.Markup.Localizer.BamlLocalizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Markup.Localizer.BamlLocalizerErrorNotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorNotify += x, x => _data.ErrorNotify -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::System.Windows.Media.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::System.Windows.Media.MediaPlayer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptCommand => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.MediaScriptCommandEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.MediaScriptCommandEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptCommand += x, x => _data.ScriptCommand -= x); + } +} + +namespace System.Windows.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClockEvents Events(this global::System.Windows.Media.Animation.Clock item) => new RxClockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::System.Windows.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClockEvents + { + private readonly global::System.Windows.Media.Animation.Clock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClockEvents(global::System.Windows.Media.Animation.Clock data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::System.Windows.Media.Animation.Timeline data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentGlobalSpeedInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentGlobalSpeedInvalidated += x, x => _data.CurrentGlobalSpeedInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateInvalidated += x, x => _data.CurrentStateInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentTimeInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentTimeInvalidated += x, x => _data.CurrentTimeInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemoveRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemoveRequested += x, x => _data.RemoveRequested -= x); + } +} + +namespace System.Windows.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapDecoderEvents Events(this global::System.Windows.Media.Imaging.BitmapDecoder item) => new RxBitmapDecoderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapSourceEvents Events(this global::System.Windows.Media.Imaging.BitmapSource item) => new RxBitmapSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapDecoderEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapDecoder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapDecoderEvents(global::System.Windows.Media.Imaging.BitmapDecoder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapSourceEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Media.Imaging.BitmapSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapSourceEvents(global::System.Windows.Media.Imaging.BitmapSource data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodeFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodeFailed += x, x => _data.DecodeFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.ExceptionEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.ExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Media.Imaging.DownloadProgressEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + } +} + +namespace System.Windows.Navigation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationServiceEvents Events(this global::System.Windows.Navigation.NavigationService item) => new RxNavigationServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationWindowEvents Events(this global::System.Windows.Navigation.NavigationWindow item) => new RxNavigationWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationServiceEvents + { + private readonly global::System.Windows.Navigation.NavigationService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationServiceEvents(global::System.Windows.Navigation.NavigationService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationWindowEvents : global::System.Windows.RxWindowEvents + { + private readonly global::System.Windows.Navigation.NavigationWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationWindowEvents(global::System.Windows.Navigation.NavigationWindow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FragmentNavigation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.FragmentNavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FragmentNavigation += x, x => _data.FragmentNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationProgress += x, x => _data.NavigationProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } +} + +namespace System.Windows.Shell +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxJumpListEvents Events(this global::System.Windows.Shell.JumpList item) => new RxJumpListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbButtonInfoEvents Events(this global::System.Windows.Shell.ThumbButtonInfo item) => new RxThumbButtonInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxJumpListEvents + { + private readonly global::System.Windows.Shell.JumpList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxJumpListEvents(global::System.Windows.Shell.JumpList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRejected => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRejectedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRejectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRejected += x, x => _data.JumpItemsRejected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable JumpItemsRemovedByUser => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Shell.JumpItemsRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Shell.JumpItemsRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.JumpItemsRemovedByUser += x, x => _data.JumpItemsRemovedByUser -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbButtonInfoEvents : global::System.Windows.RxFreezableEvents + { + private readonly global::System.Windows.Shell.ThumbButtonInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbButtonInfoEvents(global::System.Windows.Shell.ThumbButtonInfo data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } +} + +namespace System.Windows.Threading +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherEvents Events(this global::System.Windows.Threading.Dispatcher item) => new RxDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherHooksEvents Events(this global::System.Windows.Threading.DispatcherHooks item) => new RxDispatcherHooksEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherOperationEvents Events(this global::System.Windows.Threading.DispatcherOperation item) => new RxDispatcherOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::System.Windows.Threading.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherEvents + { + private readonly global::System.Windows.Threading.Dispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherEvents(global::System.Windows.Threading.Dispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownFinished += x, x => _data.ShutdownFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ShutdownStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ShutdownStarted += x, x => _data.ShutdownStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledExceptionFilter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherUnhandledExceptionFilterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledExceptionFilter += x, x => _data.UnhandledExceptionFilter -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherHooksEvents + { + private readonly global::System.Windows.Threading.DispatcherHooks _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherHooksEvents(global::System.Windows.Threading.DispatcherHooks data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DispatcherInactive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DispatcherInactive += x, x => _data.DispatcherInactive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationAborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationAborted += x, x => _data.OperationAborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPosted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPosted += x, x => _data.OperationPosted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationPriorityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationPriorityChanged += x, x => _data.OperationPriorityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OperationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Threading.DispatcherHookEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OperationStarted += x, x => _data.OperationStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherOperationEvents + { + private readonly global::System.Windows.Threading.DispatcherOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherOperationEvents(global::System.Windows.Threading.DispatcherOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Aborted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::System.Windows.Threading.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::System.Windows.Threading.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } +} + +namespace System.Windows +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemParametersStaticPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.SystemParameters.StaticPropertyChanged += x, x => global::System.Windows.SystemParameters.StaticPropertyChanged -= x); + } +} + +namespace System.Windows.Data +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionRegistering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BindingOperationsCollectionViewRegistering => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Data.CollectionViewRegisteringEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Data.CollectionViewRegisteringEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering += x, x => global::System.Windows.Data.BindingOperations.CollectionViewRegistering -= x); + } +} + +namespace System.Windows.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsGenericResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.GenericResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsStaticResourceResolved => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.StaticResourceResolvedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.StaticResourceResolved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryLoaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryLoadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ResourceDictionaryDiagnosticsThemedResourceDictionaryUnloaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.ResourceDictionaryUnloadedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded += x, x => global::System.Windows.Diagnostics.ResourceDictionaryDiagnostics.ThemedResourceDictionaryUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::System.Windows.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::System.Windows.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); + } +} + +namespace System.Windows.Forms +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationApplicationExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ApplicationExit += x, x => global::System.Windows.Forms.Application.ApplicationExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.EnterThreadModal += x, x => global::System.Windows.Forms.Application.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.Idle += x, x => global::System.Windows.Forms.Application.Idle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.LeaveThreadModal += x, x => global::System.Windows.Forms.Application.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Threading.ThreadExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadException += x, x => global::System.Windows.Forms.Application.ThreadException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ApplicationThreadExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.Application.ThreadExit += x, x => global::System.Windows.Forms.Application.ThreadExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ToolStripManagerRendererChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Forms.ToolStripManager.RendererChanged += x, x => global::System.Windows.Forms.ToolStripManager.RendererChanged -= x); + } +} + +namespace System.Windows.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CommandManagerRequerySuggested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.CommandManager.RequerySuggested += x, x => global::System.Windows.Input.CommandManager.RequerySuggested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable TouchFrameReported => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Windows.Input.TouchFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Input.Touch.FrameReported += x, x => global::System.Windows.Input.Touch.FrameReported -= x); + } +} + +namespace System.Windows.Interop +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherEnterThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.EnterThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherLeaveThreadModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal += x, x => global::System.Windows.Interop.ComponentDispatcher.LeaveThreadModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ComponentDispatcherThreadIdle => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle += x, x => global::System.Windows.Interop.ComponentDispatcher.ThreadIdle -= x); + } +} + +namespace System.Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.CompositionTarget.Rendering += x, x => global::System.Windows.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RenderCapabilityTierChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.RenderCapability.TierChanged += x, x => global::System.Windows.Media.RenderCapability.TierChanged -= x); + } +} + +namespace System.Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PixelShaderInvalidPixelShaderEncountered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered += x, x => global::System.Windows.Media.Effects.PixelShader.InvalidPixelShaderEncountered -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/uap10.0.16299.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/uap10.0.16299.approved.txt new file mode 100644 index 0000000..da39641 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/uap10.0.16299.approved.txt @@ -0,0 +1,23957 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Windows.ApplicationModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageCatalogEvents Events(this global::Windows.ApplicationModel.PackageCatalog item) => new RxPackageCatalogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageCatalogEvents + { + private readonly global::Windows.ApplicationModel.PackageCatalog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageCatalogEvents(global::Windows.ApplicationModel.PackageCatalog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args)> PackageContentGroupStaging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageContentGroupStaging += x, x => _data.PackageContentGroupStaging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args)> PackageInstalling => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageInstalling += x, x => _data.PackageInstalling -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args)> PackageStaging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageStaging += x, x => _data.PackageStaging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args)> PackageStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args)> PackageUninstalling => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args)> PackageUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + } +} + +namespace Windows.ApplicationModel.Activation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplashScreenEvents Events(this global::Windows.ApplicationModel.Activation.SplashScreen item) => new RxSplashScreenEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplashScreenEvents + { + private readonly global::Windows.ApplicationModel.Activation.SplashScreen _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplashScreenEvents(global::Windows.ApplicationModel.Activation.SplashScreen data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Activation.SplashScreen sender, object args)> Dismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Activation.SplashScreen sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Activation.SplashScreen sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); + } +} + +namespace Windows.ApplicationModel.AppExtensions +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppExtensionCatalogEvents Events(this global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog item) => new RxAppExtensionCatalogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppExtensionCatalogEvents + { + private readonly global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppExtensionCatalogEvents(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args)> PackageInstalled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageInstalled += x, x => _data.PackageInstalled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args)> PackageStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args)> PackageUninstalling => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args)> PackageUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageUpdated += x, x => _data.PackageUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args)> PackageUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + } +} + +namespace Windows.ApplicationModel.Appointments +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppointmentCalendarSyncManagerEvents Events(this global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager item) => new RxAppointmentCalendarSyncManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppointmentStoreEvents Events(this global::Windows.ApplicationModel.Appointments.AppointmentStore item) => new RxAppointmentStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppointmentCalendarSyncManagerEvents + { + private readonly global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppointmentCalendarSyncManagerEvents(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppointmentStoreEvents + { + private readonly global::Windows.ApplicationModel.Appointments.AppointmentStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppointmentStoreEvents(global::Windows.ApplicationModel.Appointments.AppointmentStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args)> StoreChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + } +} + +namespace Windows.ApplicationModel.Appointments.DataProvider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppointmentDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection item) => new RxAppointmentDataProviderConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppointmentDataProviderConnectionEvents + { + private readonly global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppointmentDataProviderConnectionEvents(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args)> CancelMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CancelMeetingRequested += x, x => _data.CancelMeetingRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args)> CreateOrUpdateAppointmentRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CreateOrUpdateAppointmentRequested += x, x => _data.CreateOrUpdateAppointmentRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args)> ForwardMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args)> ProposeNewTimeForMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args)> SyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args)> UpdateMeetingResponseRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + } +} + +namespace Windows.ApplicationModel.AppService +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppServiceConnectionEvents Events(this global::Windows.ApplicationModel.AppService.AppServiceConnection item) => new RxAppServiceConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppServiceConnectionEvents + { + private readonly global::Windows.ApplicationModel.AppService.AppServiceConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppServiceConnectionEvents(global::Windows.ApplicationModel.AppService.AppServiceConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args)> RequestReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args)> ServiceClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServiceClosed += x, x => _data.ServiceClosed -= x); + } +} + +namespace Windows.ApplicationModel.Background +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBackgroundTaskRegistrationEvents Events(this global::Windows.ApplicationModel.Background.BackgroundTaskRegistration item) => new RxBackgroundTaskRegistrationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBackgroundTaskRegistrationGroupEvents Events(this global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup item) => new RxBackgroundTaskRegistrationGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIBackgroundTaskInstanceEvents Events(this global::Windows.ApplicationModel.Background.IBackgroundTaskInstance item) => new RxIBackgroundTaskInstanceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIBackgroundTaskRegistrationEvents Events(this global::Windows.ApplicationModel.Background.IBackgroundTaskRegistration item) => new RxIBackgroundTaskRegistrationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBackgroundTaskRegistrationEvents + { + private readonly global::Windows.ApplicationModel.Background.BackgroundTaskRegistration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBackgroundTaskRegistrationEvents(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args)> Progress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Progress += x, x => _data.Progress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBackgroundTaskRegistrationGroupEvents + { + private readonly global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBackgroundTaskRegistrationGroupEvents(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args)> BackgroundActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BackgroundActivated += x, x => _data.BackgroundActivated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIBackgroundTaskInstanceEvents + { + private readonly global::Windows.ApplicationModel.Background.IBackgroundTaskInstance _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIBackgroundTaskInstanceEvents(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason)> Canceled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); + return Handler; + }, x => _data.Canceled += x, x => _data.Canceled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIBackgroundTaskRegistrationEvents + { + private readonly global::Windows.ApplicationModel.Background.IBackgroundTaskRegistration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIBackgroundTaskRegistrationEvents(global::Windows.ApplicationModel.Background.IBackgroundTaskRegistration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args)> Progress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Progress += x, x => _data.Progress -= x); + } +} + +namespace Windows.ApplicationModel.Calls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLockScreenCallUIEvents Events(this global::Windows.ApplicationModel.Calls.LockScreenCallUI item) => new RxLockScreenCallUIEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPhoneLineEvents Events(this global::Windows.ApplicationModel.Calls.PhoneLine item) => new RxPhoneLineEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPhoneLineWatcherEvents Events(this global::Windows.ApplicationModel.Calls.PhoneLineWatcher item) => new RxPhoneLineWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVoipCallCoordinatorEvents Events(this global::Windows.ApplicationModel.Calls.VoipCallCoordinator item) => new RxVoipCallCoordinatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVoipPhoneCallEvents Events(this global::Windows.ApplicationModel.Calls.VoipPhoneCall item) => new RxVoipPhoneCallEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLockScreenCallUIEvents + { + private readonly global::Windows.ApplicationModel.Calls.LockScreenCallUI _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLockScreenCallUIEvents(global::Windows.ApplicationModel.Calls.LockScreenCallUI data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, global::Windows.ApplicationModel.Calls.LockScreenCallEndRequestedEventArgs args)> EndRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, global::Windows.ApplicationModel.Calls.LockScreenCallEndRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, global::Windows.ApplicationModel.Calls.LockScreenCallEndRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EndRequested += x, x => _data.EndRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPhoneLineEvents + { + private readonly global::Windows.ApplicationModel.Calls.PhoneLine _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPhoneLineEvents(global::Windows.ApplicationModel.Calls.PhoneLine data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLine sender, object args)> LineChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLine sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLine sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LineChanged += x, x => _data.LineChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPhoneLineWatcherEvents + { + private readonly global::Windows.ApplicationModel.Calls.PhoneLineWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPhoneLineWatcherEvents(global::Windows.ApplicationModel.Calls.PhoneLineWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)> LineAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LineAdded += x, x => _data.LineAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)> LineRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LineRemoved += x, x => _data.LineRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)> LineUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LineUpdated += x, x => _data.LineUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVoipCallCoordinatorEvents + { + private readonly global::Windows.ApplicationModel.Calls.VoipCallCoordinator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVoipCallCoordinatorEvents(global::Windows.ApplicationModel.Calls.VoipCallCoordinator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipCallCoordinator sender, global::Windows.ApplicationModel.Calls.MuteChangeEventArgs args)> MuteStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipCallCoordinator sender, global::Windows.ApplicationModel.Calls.MuteChangeEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipCallCoordinator sender, global::Windows.ApplicationModel.Calls.MuteChangeEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MuteStateChanged += x, x => _data.MuteStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVoipPhoneCallEvents + { + private readonly global::Windows.ApplicationModel.Calls.VoipPhoneCall _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVoipPhoneCallEvents(global::Windows.ApplicationModel.Calls.VoipPhoneCall data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallAnswerEventArgs args)> AnswerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallAnswerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallAnswerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AnswerRequested += x, x => _data.AnswerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)> EndRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EndRequested += x, x => _data.EndRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)> HoldRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HoldRequested += x, x => _data.HoldRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallRejectEventArgs args)> RejectRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallRejectEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallRejectEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RejectRequested += x, x => _data.RejectRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)> ResumeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResumeRequested += x, x => _data.ResumeRequested -= x); + } +} + +namespace Windows.ApplicationModel.Chat +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxChatConversationEvents Events(this global::Windows.ApplicationModel.Chat.ChatConversation item) => new RxChatConversationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxChatMessageStoreEvents Events(this global::Windows.ApplicationModel.Chat.ChatMessageStore item) => new RxChatMessageStoreEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRcsEndUserMessageManagerEvents Events(this global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager item) => new RxRcsEndUserMessageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRcsTransportEvents Events(this global::Windows.ApplicationModel.Chat.RcsTransport item) => new RxRcsTransportEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxChatConversationEvents + { + private readonly global::Windows.ApplicationModel.Chat.ChatConversation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxChatConversationEvents(global::Windows.ApplicationModel.Chat.ChatConversation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args)> RemoteParticipantComposingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RemoteParticipantComposingChanged += x, x => _data.RemoteParticipantComposingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxChatMessageStoreEvents + { + private readonly global::Windows.ApplicationModel.Chat.ChatMessageStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxChatMessageStoreEvents(global::Windows.ApplicationModel.Chat.ChatMessageStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args)> MessageChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageChanged += x, x => _data.MessageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args)> StoreChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRcsEndUserMessageManagerEvents + { + private readonly global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRcsEndUserMessageManagerEvents(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args)> MessageAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageAvailableChanged += x, x => _data.MessageAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRcsTransportEvents + { + private readonly global::Windows.ApplicationModel.Chat.RcsTransport _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRcsTransportEvents(global::Windows.ApplicationModel.Chat.RcsTransport data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args)> ServiceKindSupportedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServiceKindSupportedChanged += x, x => _data.ServiceKindSupportedChanged -= x); + } +} + +namespace Windows.ApplicationModel.Contacts +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactListEvents Events(this global::Windows.ApplicationModel.Contacts.ContactList item) => new RxContactListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactListSyncManagerEvents Events(this global::Windows.ApplicationModel.Contacts.ContactListSyncManager item) => new RxContactListSyncManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactPanelEvents Events(this global::Windows.ApplicationModel.Contacts.ContactPanel item) => new RxContactPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactStoreEvents Events(this global::Windows.ApplicationModel.Contacts.ContactStore item) => new RxContactStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactListEvents + { + private readonly global::Windows.ApplicationModel.Contacts.ContactList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactListEvents(global::Windows.ApplicationModel.Contacts.ContactList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)> ContactChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactListSyncManagerEvents + { + private readonly global::Windows.ApplicationModel.Contacts.ContactListSyncManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactListSyncManagerEvents(global::Windows.ApplicationModel.Contacts.ContactListSyncManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactPanelEvents + { + private readonly global::Windows.ApplicationModel.Contacts.ContactPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactPanelEvents(global::Windows.ApplicationModel.Contacts.ContactPanel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args)> LaunchFullAppRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LaunchFullAppRequested += x, x => _data.LaunchFullAppRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactStoreEvents + { + private readonly global::Windows.ApplicationModel.Contacts.ContactStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactStoreEvents(global::Windows.ApplicationModel.Contacts.ContactStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)> ContactChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + } +} + +namespace Windows.ApplicationModel.Contacts.DataProvider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection item) => new RxContactDataProviderConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactDataProviderConnectionEvents + { + private readonly global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactDataProviderConnectionEvents(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args)> CreateOrUpdateContactRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CreateOrUpdateContactRequested += x, x => _data.CreateOrUpdateContactRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args)> DeleteContactRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DeleteContactRequested += x, x => _data.DeleteContactRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args)> ServerSearchReadBatchRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args)> SyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + } +} + +namespace Windows.ApplicationModel.Contacts.Provider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactPickerUIEvents Events(this global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI item) => new RxContactPickerUIEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactPickerUIEvents + { + private readonly global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactPickerUIEvents(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args)> ContactRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContactRemoved += x, x => _data.ContactRemoved -= x); + } +} + +namespace Windows.ApplicationModel.ConversationalAgent +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxActivationSignalDetectionConfigurationEvents Events(this global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration item) => new RxActivationSignalDetectionConfigurationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxConversationalAgentSessionEvents Events(this global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession item) => new RxConversationalAgentSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxActivationSignalDetectionConfigurationEvents + { + private readonly global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxActivationSignalDetectionConfigurationEvents(global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration sender, global::Windows.ApplicationModel.ConversationalAgent.DetectionConfigurationAvailabilityChangedEventArgs args)> AvailabilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration sender, global::Windows.ApplicationModel.ConversationalAgent.DetectionConfigurationAvailabilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration sender, global::Windows.ApplicationModel.ConversationalAgent.DetectionConfigurationAvailabilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxConversationalAgentSessionEvents + { + private readonly global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxConversationalAgentSessionEvents(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSessionInterruptedEventArgs args)> SessionInterrupted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSessionInterruptedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSessionInterruptedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionInterrupted += x, x => _data.SessionInterrupted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSignalDetectedEventArgs args)> SignalDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSignalDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSignalDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SignalDetected += x, x => _data.SignalDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSystemStateChangedEventArgs args)> SystemStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSystemStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSystemStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemStateChanged += x, x => _data.SystemStateChanged -= x); + } +} + +namespace Windows.ApplicationModel.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreApplicationViewEvents Events(this global::Windows.ApplicationModel.Core.CoreApplicationView item) => new RxCoreApplicationViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreApplicationViewTitleBarEvents Events(this global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar item) => new RxCoreApplicationViewTitleBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICoreApplicationUnhandledErrorEvents Events(this global::Windows.ApplicationModel.Core.ICoreApplicationUnhandledError item) => new RxICoreApplicationUnhandledErrorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreApplicationViewEvents + { + private readonly global::Windows.ApplicationModel.Core.CoreApplicationView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreApplicationViewEvents(global::Windows.ApplicationModel.Core.CoreApplicationView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args)> HostedViewClosing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HostedViewClosing += x, x => _data.HostedViewClosing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreApplicationViewTitleBarEvents + { + private readonly global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreApplicationViewTitleBarEvents(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)> IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)> LayoutMetricsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LayoutMetricsChanged += x, x => _data.LayoutMetricsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICoreApplicationUnhandledErrorEvents + { + private readonly global::Windows.ApplicationModel.Core.ICoreApplicationUnhandledError _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICoreApplicationUnhandledErrorEvents(global::Windows.ApplicationModel.Core.ICoreApplicationUnhandledError data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledErrorDetected => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledErrorDetected += x, x => _data.UnhandledErrorDetected -= x); + } +} + +namespace Windows.ApplicationModel.DataTransfer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataPackageEvents Events(this global::Windows.ApplicationModel.DataTransfer.DataPackage item) => new RxDataPackageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataTransferManagerEvents Events(this global::Windows.ApplicationModel.DataTransfer.DataTransferManager item) => new RxDataTransferManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataPackageEvents + { + private readonly global::Windows.ApplicationModel.DataTransfer.DataPackage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataPackageEvents(global::Windows.ApplicationModel.DataTransfer.DataPackage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args)> Destroyed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args)> OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args)> ShareCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShareCanceled += x, x => _data.ShareCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args)> ShareCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShareCompleted += x, x => _data.ShareCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataTransferManagerEvents + { + private readonly global::Windows.ApplicationModel.DataTransfer.DataTransferManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataTransferManagerEvents(global::Windows.ApplicationModel.DataTransfer.DataTransferManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args)> DataRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataRequested += x, x => _data.DataRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args)> ShareProvidersRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShareProvidersRequested += x, x => _data.ShareProvidersRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args)> TargetApplicationChosen => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TargetApplicationChosen += x, x => _data.TargetApplicationChosen -= x); + } +} + +namespace Windows.ApplicationModel.DataTransfer.DragDrop.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreDragDropManagerEvents Events(this global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager item) => new RxCoreDragDropManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreDragDropManagerEvents + { + private readonly global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreDragDropManagerEvents(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args)> TargetRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TargetRequested += x, x => _data.TargetRequested -= x); + } +} + +namespace Windows.ApplicationModel.Email +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEmailMailboxEvents Events(this global::Windows.ApplicationModel.Email.EmailMailbox item) => new RxEmailMailboxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEmailMailboxSyncManagerEvents Events(this global::Windows.ApplicationModel.Email.EmailMailboxSyncManager item) => new RxEmailMailboxSyncManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEmailMailboxEvents + { + private readonly global::Windows.ApplicationModel.Email.EmailMailbox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEmailMailboxEvents(global::Windows.ApplicationModel.Email.EmailMailbox data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args)> MailboxChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MailboxChanged += x, x => _data.MailboxChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEmailMailboxSyncManagerEvents + { + private readonly global::Windows.ApplicationModel.Email.EmailMailboxSyncManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEmailMailboxSyncManagerEvents(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + } +} + +namespace Windows.ApplicationModel.Email.DataProvider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEmailDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection item) => new RxEmailDataProviderConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEmailDataProviderConnectionEvents + { + private readonly global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEmailDataProviderConnectionEvents(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args)> CreateFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CreateFolderRequested += x, x => _data.CreateFolderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args)> DeleteFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DeleteFolderRequested += x, x => _data.DeleteFolderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args)> DownloadAttachmentRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadAttachmentRequested += x, x => _data.DownloadAttachmentRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args)> DownloadMessageRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadMessageRequested += x, x => _data.DownloadMessageRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args)> EmptyFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EmptyFolderRequested += x, x => _data.EmptyFolderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args)> ForwardMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args)> GetAutoReplySettingsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GetAutoReplySettingsRequested += x, x => _data.GetAutoReplySettingsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args)> MailboxSyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MailboxSyncRequested += x, x => _data.MailboxSyncRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args)> MoveFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MoveFolderRequested += x, x => _data.MoveFolderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args)> ProposeNewTimeForMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args)> ResolveRecipientsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResolveRecipientsRequested += x, x => _data.ResolveRecipientsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args)> ServerSearchReadBatchRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args)> SetAutoReplySettingsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SetAutoReplySettingsRequested += x, x => _data.SetAutoReplySettingsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args)> UpdateMeetingResponseRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args)> ValidateCertificatesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValidateCertificatesRequested += x, x => _data.ValidateCertificatesRequested -= x); + } +} + +namespace Windows.ApplicationModel.ExtendedExecution +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExtendedExecutionSessionEvents Events(this global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionSession item) => new RxExtendedExecutionSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExtendedExecutionSessionEvents + { + private readonly global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExtendedExecutionSessionEvents(global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Revoked => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionRevokedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionRevokedEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.Revoked += x, x => _data.Revoked -= x); + } +} + +namespace Windows.ApplicationModel.ExtendedExecution.Foreground +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExtendedExecutionForegroundSessionEvents Events(this global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundSession item) => new RxExtendedExecutionForegroundSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExtendedExecutionForegroundSessionEvents + { + private readonly global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExtendedExecutionForegroundSessionEvents(global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Revoked => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundRevokedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundRevokedEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.Revoked += x, x => _data.Revoked -= x); + } +} + +namespace Windows.ApplicationModel.LockScreen +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLockApplicationHostEvents Events(this global::Windows.ApplicationModel.LockScreen.LockApplicationHost item) => new RxLockApplicationHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLockScreenInfoEvents Events(this global::Windows.ApplicationModel.LockScreen.LockScreenInfo item) => new RxLockScreenInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLockApplicationHostEvents + { + private readonly global::Windows.ApplicationModel.LockScreen.LockApplicationHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLockApplicationHostEvents(global::Windows.ApplicationModel.LockScreen.LockApplicationHost data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args)> Unlocking => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Unlocking += x, x => _data.Unlocking -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLockScreenInfoEvents + { + private readonly global::Windows.ApplicationModel.LockScreen.LockScreenInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLockScreenInfoEvents(global::Windows.ApplicationModel.LockScreen.LockScreenInfo data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> AlarmIconChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AlarmIconChanged += x, x => _data.AlarmIconChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> BadgesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BadgesChanged += x, x => _data.BadgesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> DetailTextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DetailTextChanged += x, x => _data.DetailTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> LockScreenImageChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LockScreenImageChanged += x, x => _data.LockScreenImageChanged -= x); + } +} + +namespace Windows.ApplicationModel.Preview.Notes +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotesWindowManagerPreviewEvents Events(this global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview item) => new RxNotesWindowManagerPreviewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotesWindowManagerPreviewEvents + { + private readonly global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotesWindowManagerPreviewEvents(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NotePlacementChangedPreviewEventArgs args)> NotePlacementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NotePlacementChangedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NotePlacementChangedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NotePlacementChanged += x, x => _data.NotePlacementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NoteVisibilityChangedPreviewEventArgs args)> NoteVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NoteVisibilityChangedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NoteVisibilityChangedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NoteVisibilityChanged += x, x => _data.NoteVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, object args)> SystemLockStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemLockStateChanged += x, x => _data.SystemLockStateChanged -= x); + } +} + +namespace Windows.ApplicationModel.Resources.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxResourceQualifierObservableMapEvents Events(this global::Windows.ApplicationModel.Resources.Core.ResourceQualifierObservableMap item) => new RxResourceQualifierObservableMapEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxResourceQualifierObservableMapEvents + { + private readonly global::Windows.ApplicationModel.Resources.Core.ResourceQualifierObservableMap _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxResourceQualifierObservableMapEvents(global::Windows.ApplicationModel.Resources.Core.ResourceQualifierObservableMap data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } +} + +namespace Windows.ApplicationModel.Search +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSearchPaneEvents Events(this global::Windows.ApplicationModel.Search.SearchPane item) => new RxSearchPaneEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSearchPaneEvents + { + private readonly global::Windows.ApplicationModel.Search.SearchPane _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSearchPaneEvents(global::Windows.ApplicationModel.Search.SearchPane data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQueryChangedEventArgs args)> QueryChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQueryChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQueryChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QueryChanged += x, x => _data.QueryChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQuerySubmittedEventArgs args)> QuerySubmitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQuerySubmittedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQuerySubmittedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneResultSuggestionChosenEventArgs args)> ResultSuggestionChosen => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneResultSuggestionChosenEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneResultSuggestionChosenEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneSuggestionsRequestedEventArgs args)> SuggestionsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneSuggestionsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneSuggestionsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneVisibilityChangedEventArgs args)> VisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneVisibilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneVisibilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + } +} + +namespace Windows.ApplicationModel.Search.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSearchSuggestionManagerEvents Events(this global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager item) => new RxSearchSuggestionManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSearchSuggestionManagerEvents + { + private readonly global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSearchSuggestionManagerEvents(global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.RequestingFocusOnKeyboardInputEventArgs args)> RequestingFocusOnKeyboardInput => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.RequestingFocusOnKeyboardInputEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.RequestingFocusOnKeyboardInputEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RequestingFocusOnKeyboardInput += x, x => _data.RequestingFocusOnKeyboardInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.SearchSuggestionsRequestedEventArgs args)> SuggestionsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.SearchSuggestionsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.SearchSuggestionsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); + } +} + +namespace Windows.ApplicationModel.Store +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLicenseInformationEvents Events(this global::Windows.ApplicationModel.Store.LicenseInformation item) => new RxLicenseInformationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLicenseInformationEvents + { + private readonly global::Windows.ApplicationModel.Store.LicenseInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLicenseInformationEvents(global::Windows.ApplicationModel.Store.LicenseInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LicenseChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler() => eventHandler(global::System.Reactive.Unit.Default); + return Handler; + }, x => _data.LicenseChanged += x, x => _data.LicenseChanged -= x); + } +} + +namespace Windows.ApplicationModel.Store.Preview.InstallControl +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppInstallItemEvents Events(this global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem item) => new RxAppInstallItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppInstallManagerEvents Events(this global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager item) => new RxAppInstallManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppInstallItemEvents + { + private readonly global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppInstallItemEvents(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppInstallManagerEvents + { + private readonly global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppInstallManagerEvents(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)> ItemCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemCompleted += x, x => _data.ItemCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)> ItemStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemStatusChanged += x, x => _data.ItemStatusChanged -= x); + } +} + +namespace Windows.ApplicationModel.UserActivities +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserActivityRequestManagerEvents Events(this global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager item) => new RxUserActivityRequestManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserActivityRequestManagerEvents + { + private readonly global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserActivityRequestManagerEvents(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args)> UserActivityRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserActivityRequested += x, x => _data.UserActivityRequested -= x); + } +} + +namespace Windows.ApplicationModel.UserDataAccounts +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserDataAccountStoreEvents Events(this global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore item) => new RxUserDataAccountStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserDataAccountStoreEvents + { + private readonly global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserDataAccountStoreEvents(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args)> StoreChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + } +} + +namespace Windows.ApplicationModel.UserDataTasks +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserDataTaskListSyncManagerEvents Events(this global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager item) => new RxUserDataTaskListSyncManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserDataTaskListSyncManagerEvents + { + private readonly global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserDataTaskListSyncManagerEvents(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + } +} + +namespace Windows.ApplicationModel.UserDataTasks.DataProvider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserDataTaskDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection item) => new RxUserDataTaskDataProviderConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserDataTaskDataProviderConnectionEvents + { + private readonly global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserDataTaskDataProviderConnectionEvents(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args)> CompleteTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CompleteTaskRequested += x, x => _data.CompleteTaskRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args)> CreateOrUpdateTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CreateOrUpdateTaskRequested += x, x => _data.CreateOrUpdateTaskRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args)> DeleteTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DeleteTaskRequested += x, x => _data.DeleteTaskRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args)> SkipOccurrenceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SkipOccurrenceRequested += x, x => _data.SkipOccurrenceRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args)> SyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + } +} + +namespace Windows.ApplicationModel.VoiceCommands +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVoiceCommandServiceConnectionEvents Events(this global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection item) => new RxVoiceCommandServiceConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVoiceCommandServiceConnectionEvents + { + private readonly global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVoiceCommandServiceConnectionEvents(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args)> VoiceCommandCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VoiceCommandCompleted += x, x => _data.VoiceCommandCompleted -= x); + } +} + +namespace Windows.ApplicationModel.Wallet.System +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWalletItemSystemStoreEvents Events(this global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore item) => new RxWalletItemSystemStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWalletItemSystemStoreEvents + { + private readonly global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWalletItemSystemStoreEvents(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args)> ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + } +} + +namespace Windows.Devices.AllJoyn +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAllJoynBusAttachmentEvents Events(this global::Windows.Devices.AllJoyn.AllJoynBusAttachment item) => new RxAllJoynBusAttachmentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAllJoynBusObjectEvents Events(this global::Windows.Devices.AllJoyn.AllJoynBusObject item) => new RxAllJoynBusObjectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAllJoynSessionEvents Events(this global::Windows.Devices.AllJoyn.AllJoynSession item) => new RxAllJoynSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAllJoynBusAttachmentEvents + { + private readonly global::Windows.Devices.AllJoyn.AllJoynBusAttachment _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAllJoynBusAttachmentEvents(global::Windows.Devices.AllJoyn.AllJoynBusAttachment data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args)> AcceptSessionJoinerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AcceptSessionJoinerRequested += x, x => _data.AcceptSessionJoinerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args)> AuthenticationComplete => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AuthenticationComplete += x, x => _data.AuthenticationComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args)> CredentialsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CredentialsRequested += x, x => _data.CredentialsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args)> CredentialsVerificationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CredentialsVerificationRequested += x, x => _data.CredentialsVerificationRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args)> SessionJoined => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionJoined += x, x => _data.SessionJoined -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAllJoynBusObjectEvents + { + private readonly global::Windows.Devices.AllJoyn.AllJoynBusObject _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAllJoynBusObjectEvents(global::Windows.Devices.AllJoyn.AllJoynBusObject data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAllJoynSessionEvents + { + private readonly global::Windows.Devices.AllJoyn.AllJoynSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAllJoynSessionEvents(global::Windows.Devices.AllJoyn.AllJoynSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args)> Lost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Lost += x, x => _data.Lost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args)> MemberAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MemberAdded += x, x => _data.MemberAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args)> MemberRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MemberRemoved += x, x => _data.MemberRemoved -= x); + } +} + +namespace Windows.Devices.Bluetooth +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBluetoothDeviceEvents Events(this global::Windows.Devices.Bluetooth.BluetoothDevice item) => new RxBluetoothDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBluetoothLEDeviceEvents Events(this global::Windows.Devices.Bluetooth.BluetoothLEDevice item) => new RxBluetoothLEDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBluetoothDeviceEvents + { + private readonly global::Windows.Devices.Bluetooth.BluetoothDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBluetoothDeviceEvents(global::Windows.Devices.Bluetooth.BluetoothDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)> ConnectionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)> NameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)> SdpRecordsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SdpRecordsChanged += x, x => _data.SdpRecordsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBluetoothLEDeviceEvents + { + private readonly global::Windows.Devices.Bluetooth.BluetoothLEDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBluetoothLEDeviceEvents(global::Windows.Devices.Bluetooth.BluetoothLEDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)> ConnectionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)> GattServicesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GattServicesChanged += x, x => _data.GattServicesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)> NameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); + } +} + +namespace Windows.Devices.Bluetooth.Advertisement +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBluetoothLEAdvertisementPublisherEvents Events(this global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher item) => new RxBluetoothLEAdvertisementPublisherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBluetoothLEAdvertisementWatcherEvents Events(this global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher item) => new RxBluetoothLEAdvertisementWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBluetoothLEAdvertisementPublisherEvents + { + private readonly global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBluetoothLEAdvertisementPublisherEvents(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBluetoothLEAdvertisementWatcherEvents + { + private readonly global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBluetoothLEAdvertisementWatcherEvents(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args)> Received => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Received += x, x => _data.Received -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } +} + +namespace Windows.Devices.Bluetooth.GenericAttributeProfile +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattCharacteristicEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic item) => new RxGattCharacteristicEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattLocalCharacteristicEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic item) => new RxGattLocalCharacteristicEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattLocalDescriptorEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor item) => new RxGattLocalDescriptorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattReadRequestEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest item) => new RxGattReadRequestEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattServiceProviderEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider item) => new RxGattServiceProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattSessionEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession item) => new RxGattSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattSubscribedClientEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient item) => new RxGattSubscribedClientEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattWriteRequestEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest item) => new RxGattWriteRequestEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattCharacteristicEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattCharacteristicEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args)> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattLocalCharacteristicEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattLocalCharacteristicEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)> ReadRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args)> SubscribedClientsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SubscribedClientsChanged += x, x => _data.SubscribedClientsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)> WriteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattLocalDescriptorEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattLocalDescriptorEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)> ReadRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)> WriteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattReadRequestEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattReadRequestEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattServiceProviderEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattServiceProviderEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args)> AdvertisementStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattSessionEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattSessionEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args)> MaxPduSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MaxPduSizeChanged += x, x => _data.MaxPduSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args)> SessionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattSubscribedClientEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattSubscribedClientEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args)> MaxNotificationSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MaxNotificationSizeChanged += x, x => _data.MaxNotificationSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattWriteRequestEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattWriteRequestEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace Windows.Devices.Display.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDisplayManagerEvents Events(this global::Windows.Devices.Display.Core.DisplayManager item) => new RxDisplayManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDisplayManagerEvents + { + private readonly global::Windows.Devices.Display.Core.DisplayManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDisplayManagerEvents(global::Windows.Devices.Display.Core.DisplayManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args)> Disabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Disabled += x, x => _data.Disabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args)> Enabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Enabled += x, x => _data.Enabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args)> PathsFailedOrInvalidated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PathsFailedOrInvalidated += x, x => _data.PathsFailedOrInvalidated -= x); + } +} + +namespace Windows.Devices.Enumeration +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDeviceAccessInformationEvents Events(this global::Windows.Devices.Enumeration.DeviceAccessInformation item) => new RxDeviceAccessInformationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDeviceInformationCustomPairingEvents Events(this global::Windows.Devices.Enumeration.DeviceInformationCustomPairing item) => new RxDeviceInformationCustomPairingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDevicePickerEvents Events(this global::Windows.Devices.Enumeration.DevicePicker item) => new RxDevicePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDeviceWatcherEvents Events(this global::Windows.Devices.Enumeration.DeviceWatcher item) => new RxDeviceWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDeviceAccessInformationEvents + { + private readonly global::Windows.Devices.Enumeration.DeviceAccessInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDeviceAccessInformationEvents(global::Windows.Devices.Enumeration.DeviceAccessInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args)> AccessChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessChanged += x, x => _data.AccessChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDeviceInformationCustomPairingEvents + { + private readonly global::Windows.Devices.Enumeration.DeviceInformationCustomPairing _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDeviceInformationCustomPairingEvents(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args)> PairingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PairingRequested += x, x => _data.PairingRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDevicePickerEvents + { + private readonly global::Windows.Devices.Enumeration.DevicePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDevicePickerEvents(global::Windows.Devices.Enumeration.DevicePicker data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DevicePicker sender, object args)> DevicePickerDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DevicePicker sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DevicePickerDismissed += x, x => _data.DevicePickerDismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args)> DeviceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DeviceSelected += x, x => _data.DeviceSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args)> DisconnectButtonClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDeviceWatcherEvents + { + private readonly global::Windows.Devices.Enumeration.DeviceWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDeviceWatcherEvents(global::Windows.Devices.Enumeration.DeviceWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace Windows.Devices.Enumeration.Pnp +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPnpObjectWatcherEvents Events(this global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher item) => new RxPnpObjectWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPnpObjectWatcherEvents + { + private readonly global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPnpObjectWatcherEvents(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace Windows.Devices.Geolocation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGeolocatorEvents Events(this global::Windows.Devices.Geolocation.Geolocator item) => new RxGeolocatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGeovisitMonitorEvents Events(this global::Windows.Devices.Geolocation.GeovisitMonitor item) => new RxGeovisitMonitorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGeolocatorEvents + { + private readonly global::Windows.Devices.Geolocation.Geolocator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGeolocatorEvents(global::Windows.Devices.Geolocation.Geolocator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args)> PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGeovisitMonitorEvents + { + private readonly global::Windows.Devices.Geolocation.GeovisitMonitor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGeovisitMonitorEvents(global::Windows.Devices.Geolocation.GeovisitMonitor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args)> VisitStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisitStateChanged += x, x => _data.VisitStateChanged -= x); + } +} + +namespace Windows.Devices.Geolocation.Geofencing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGeofenceMonitorEvents Events(this global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor item) => new RxGeofenceMonitorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGeofenceMonitorEvents + { + private readonly global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGeofenceMonitorEvents(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)> GeofenceStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GeofenceStateChanged += x, x => _data.GeofenceStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } +} + +namespace Windows.Devices.Gpio +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGpioPinEvents Events(this global::Windows.Devices.Gpio.GpioPin item) => new RxGpioPinEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGpioPinEvents + { + private readonly global::Windows.Devices.Gpio.GpioPin _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGpioPinEvents(global::Windows.Devices.Gpio.GpioPin data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Gpio.GpioPin sender, global::Windows.Devices.Gpio.GpioPinValueChangedEventArgs args)> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Gpio.GpioPin sender, global::Windows.Devices.Gpio.GpioPinValueChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Gpio.GpioPin sender, global::Windows.Devices.Gpio.GpioPinValueChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } +} + +namespace Windows.Devices.Gpio.Provider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIGpioPinProviderEvents Events(this global::Windows.Devices.Gpio.Provider.IGpioPinProvider item) => new RxIGpioPinProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIGpioPinProviderEvents + { + private readonly global::Windows.Devices.Gpio.Provider.IGpioPinProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIGpioPinProviderEvents(global::Windows.Devices.Gpio.Provider.IGpioPinProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Gpio.Provider.IGpioPinProvider sender, global::Windows.Devices.Gpio.Provider.GpioPinProviderValueChangedEventArgs args)> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Gpio.Provider.IGpioPinProvider sender, global::Windows.Devices.Gpio.Provider.GpioPinProviderValueChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Gpio.Provider.IGpioPinProvider sender, global::Windows.Devices.Gpio.Provider.GpioPinProviderValueChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } +} + +namespace Windows.Devices.HumanInterfaceDevice +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHidDeviceEvents Events(this global::Windows.Devices.HumanInterfaceDevice.HidDevice item) => new RxHidDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHidDeviceEvents + { + private readonly global::Windows.Devices.HumanInterfaceDevice.HidDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHidDeviceEvents(global::Windows.Devices.HumanInterfaceDevice.HidDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args)> InputReportReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InputReportReceived += x, x => _data.InputReportReceived -= x); + } +} + +namespace Windows.Devices.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMouseDeviceEvents Events(this global::Windows.Devices.Input.MouseDevice item) => new RxMouseDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPenButtonListenerEvents Events(this global::Windows.Devices.Input.PenButtonListener item) => new RxPenButtonListenerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPenDockListenerEvents Events(this global::Windows.Devices.Input.PenDockListener item) => new RxPenDockListenerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMouseDeviceEvents + { + private readonly global::Windows.Devices.Input.MouseDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMouseDeviceEvents(global::Windows.Devices.Input.MouseDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args)> MouseMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MouseMoved += x, x => _data.MouseMoved -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPenButtonListenerEvents + { + private readonly global::Windows.Devices.Input.PenButtonListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPenButtonListenerEvents(global::Windows.Devices.Input.PenButtonListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenButtonListener sender, object args)> IsSupportedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenButtonListener sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenButtonListener sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonClickedEventArgs args)> TailButtonClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonClickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonClickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TailButtonClicked += x, x => _data.TailButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonDoubleClickedEventArgs args)> TailButtonDoubleClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonDoubleClickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonDoubleClickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TailButtonDoubleClicked += x, x => _data.TailButtonDoubleClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonLongPressedEventArgs args)> TailButtonLongPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonLongPressedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonLongPressedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TailButtonLongPressed += x, x => _data.TailButtonLongPressed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPenDockListenerEvents + { + private readonly global::Windows.Devices.Input.PenDockListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPenDockListenerEvents(global::Windows.Devices.Input.PenDockListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenDockedEventArgs args)> Docked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenDockedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenDockedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Docked += x, x => _data.Docked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenDockListener sender, object args)> IsSupportedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenDockListener sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenDockListener sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenUndockedEventArgs args)> Undocked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenUndockedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenUndockedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Undocked += x, x => _data.Undocked -= x); + } +} + +namespace Windows.Devices.Input.Preview +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGazeDeviceWatcherPreviewEvents Events(this global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview item) => new RxGazeDeviceWatcherPreviewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGazeInputSourcePreviewEvents Events(this global::Windows.Devices.Input.Preview.GazeInputSourcePreview item) => new RxGazeInputSourcePreviewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGazeDeviceWatcherPreviewEvents + { + private readonly global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGazeDeviceWatcherPreviewEvents(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGazeInputSourcePreviewEvents + { + private readonly global::Windows.Devices.Input.Preview.GazeInputSourcePreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGazeInputSourcePreviewEvents(global::Windows.Devices.Input.Preview.GazeInputSourcePreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args)> GazeEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GazeEntered += x, x => _data.GazeEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args)> GazeExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GazeExited += x, x => _data.GazeExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args)> GazeMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GazeMoved += x, x => _data.GazeMoved -= x); + } +} + +namespace Windows.Devices.Lights +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLampEvents Events(this global::Windows.Devices.Lights.Lamp item) => new RxLampEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLampEvents + { + private readonly global::Windows.Devices.Lights.Lamp _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLampEvents(global::Windows.Devices.Lights.Lamp data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args)> AvailabilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); + } +} + +namespace Windows.Devices.Lights.Effects +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLampArrayBitmapEffectEvents Events(this global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect item) => new RxLampArrayBitmapEffectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLampArrayCustomEffectEvents Events(this global::Windows.Devices.Lights.Effects.LampArrayCustomEffect item) => new RxLampArrayCustomEffectEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLampArrayBitmapEffectEvents + { + private readonly global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLampArrayBitmapEffectEvents(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args)> BitmapRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLampArrayCustomEffectEvents + { + private readonly global::Windows.Devices.Lights.Effects.LampArrayCustomEffect _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLampArrayCustomEffectEvents(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args)> UpdateRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UpdateRequested += x, x => _data.UpdateRequested -= x); + } +} + +namespace Windows.Devices.Midi +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMidiInPortEvents Events(this global::Windows.Devices.Midi.MidiInPort item) => new RxMidiInPortEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMidiInPortEvents + { + private readonly global::Windows.Devices.Midi.MidiInPort _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMidiInPortEvents(global::Windows.Devices.Midi.MidiInPort data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } +} + +namespace Windows.Devices.Perception +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionColorFrameReaderEvents Events(this global::Windows.Devices.Perception.PerceptionColorFrameReader item) => new RxPerceptionColorFrameReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionColorFrameSourceEvents Events(this global::Windows.Devices.Perception.PerceptionColorFrameSource item) => new RxPerceptionColorFrameSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionColorFrameSourceWatcherEvents Events(this global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher item) => new RxPerceptionColorFrameSourceWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionControlSessionEvents Events(this global::Windows.Devices.Perception.PerceptionControlSession item) => new RxPerceptionControlSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionDepthFrameReaderEvents Events(this global::Windows.Devices.Perception.PerceptionDepthFrameReader item) => new RxPerceptionDepthFrameReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionDepthFrameSourceEvents Events(this global::Windows.Devices.Perception.PerceptionDepthFrameSource item) => new RxPerceptionDepthFrameSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionDepthFrameSourceWatcherEvents Events(this global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher item) => new RxPerceptionDepthFrameSourceWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionInfraredFrameReaderEvents Events(this global::Windows.Devices.Perception.PerceptionInfraredFrameReader item) => new RxPerceptionInfraredFrameReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionInfraredFrameSourceEvents Events(this global::Windows.Devices.Perception.PerceptionInfraredFrameSource item) => new RxPerceptionInfraredFrameSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionInfraredFrameSourceWatcherEvents Events(this global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher item) => new RxPerceptionInfraredFrameSourceWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionColorFrameReaderEvents + { + private readonly global::Windows.Devices.Perception.PerceptionColorFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionColorFrameReaderEvents(global::Windows.Devices.Perception.PerceptionColorFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionColorFrameSourceEvents + { + private readonly global::Windows.Devices.Perception.PerceptionColorFrameSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionColorFrameSourceEvents(global::Windows.Devices.Perception.PerceptionColorFrameSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> ActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> CameraIntrinsicsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)> PropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> VideoProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionColorFrameSourceWatcherEvents + { + private readonly global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionColorFrameSourceWatcherEvents(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args)> SourceAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args)> SourceRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionControlSessionEvents + { + private readonly global::Windows.Devices.Perception.PerceptionControlSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionControlSessionEvents(global::Windows.Devices.Perception.PerceptionControlSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionControlSession sender, object args)> ControlLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionControlSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionControlSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionDepthFrameReaderEvents + { + private readonly global::Windows.Devices.Perception.PerceptionDepthFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionDepthFrameReaderEvents(global::Windows.Devices.Perception.PerceptionDepthFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionDepthFrameSourceEvents + { + private readonly global::Windows.Devices.Perception.PerceptionDepthFrameSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionDepthFrameSourceEvents(global::Windows.Devices.Perception.PerceptionDepthFrameSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> ActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> CameraIntrinsicsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)> PropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> VideoProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionDepthFrameSourceWatcherEvents + { + private readonly global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionDepthFrameSourceWatcherEvents(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args)> SourceAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args)> SourceRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionInfraredFrameReaderEvents + { + private readonly global::Windows.Devices.Perception.PerceptionInfraredFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionInfraredFrameReaderEvents(global::Windows.Devices.Perception.PerceptionInfraredFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionInfraredFrameSourceEvents + { + private readonly global::Windows.Devices.Perception.PerceptionInfraredFrameSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionInfraredFrameSourceEvents(global::Windows.Devices.Perception.PerceptionInfraredFrameSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> ActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> CameraIntrinsicsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)> PropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> VideoProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionInfraredFrameSourceWatcherEvents + { + private readonly global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionInfraredFrameSourceWatcherEvents(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args)> SourceAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args)> SourceRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } +} + +namespace Windows.Devices.PointOfService +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBarcodeScannerEvents Events(this global::Windows.Devices.PointOfService.BarcodeScanner item) => new RxBarcodeScannerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCashDrawerEvents Events(this global::Windows.Devices.PointOfService.CashDrawer item) => new RxCashDrawerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCashDrawerCloseAlarmEvents Events(this global::Windows.Devices.PointOfService.CashDrawerCloseAlarm item) => new RxCashDrawerCloseAlarmEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCashDrawerEventSourceEvents Events(this global::Windows.Devices.PointOfService.CashDrawerEventSource item) => new RxCashDrawerEventSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClaimedBarcodeScannerEvents Events(this global::Windows.Devices.PointOfService.ClaimedBarcodeScanner item) => new RxClaimedBarcodeScannerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClaimedCashDrawerEvents Events(this global::Windows.Devices.PointOfService.ClaimedCashDrawer item) => new RxClaimedCashDrawerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClaimedLineDisplayEvents Events(this global::Windows.Devices.PointOfService.ClaimedLineDisplay item) => new RxClaimedLineDisplayEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClaimedMagneticStripeReaderEvents Events(this global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader item) => new RxClaimedMagneticStripeReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClaimedPosPrinterEvents Events(this global::Windows.Devices.PointOfService.ClaimedPosPrinter item) => new RxClaimedPosPrinterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMagneticStripeReaderEvents Events(this global::Windows.Devices.PointOfService.MagneticStripeReader item) => new RxMagneticStripeReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPosPrinterEvents Events(this global::Windows.Devices.PointOfService.PosPrinter item) => new RxPosPrinterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBarcodeScannerEvents + { + private readonly global::Windows.Devices.PointOfService.BarcodeScanner _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBarcodeScannerEvents(global::Windows.Devices.PointOfService.BarcodeScanner data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCashDrawerEvents + { + private readonly global::Windows.Devices.PointOfService.CashDrawer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCashDrawerEvents(global::Windows.Devices.PointOfService.CashDrawer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCashDrawerCloseAlarmEvents + { + private readonly global::Windows.Devices.PointOfService.CashDrawerCloseAlarm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCashDrawerCloseAlarmEvents(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args)> AlarmTimeoutExpired => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AlarmTimeoutExpired += x, x => _data.AlarmTimeoutExpired -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCashDrawerEventSourceEvents + { + private readonly global::Windows.Devices.PointOfService.CashDrawerEventSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCashDrawerEventSourceEvents(global::Windows.Devices.PointOfService.CashDrawerEventSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args)> DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args)> DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClaimedBarcodeScannerEvents + { + private readonly global::Windows.Devices.PointOfService.ClaimedBarcodeScanner _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClaimedBarcodeScannerEvents(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args)> DataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args)> ImagePreviewReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ImagePreviewReceived += x, x => _data.ImagePreviewReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner>(eventHandler => + { + void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); + return Handler; + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TriggerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner>(eventHandler => + { + void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); + return Handler; + }, x => _data.TriggerPressed += x, x => _data.TriggerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TriggerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner>(eventHandler => + { + void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); + return Handler; + }, x => _data.TriggerReleased += x, x => _data.TriggerReleased -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClaimedCashDrawerEvents + { + private readonly global::Windows.Devices.PointOfService.ClaimedCashDrawer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClaimedCashDrawerEvents(global::Windows.Devices.PointOfService.ClaimedCashDrawer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args)> ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClaimedLineDisplayEvents + { + private readonly global::Windows.Devices.PointOfService.ClaimedLineDisplay _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClaimedLineDisplayEvents(global::Windows.Devices.PointOfService.ClaimedLineDisplay data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args)> ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClaimedMagneticStripeReaderEvents + { + private readonly global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClaimedMagneticStripeReaderEvents(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args)> AamvaCardDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AamvaCardDataReceived += x, x => _data.AamvaCardDataReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args)> BankCardDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BankCardDataReceived += x, x => _data.BankCardDataReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader>(eventHandler => + { + void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader e) => eventHandler(e); + return Handler; + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args)> VendorSpecificDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VendorSpecificDataReceived += x, x => _data.VendorSpecificDataReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClaimedPosPrinterEvents + { + private readonly global::Windows.Devices.PointOfService.ClaimedPosPrinter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClaimedPosPrinterEvents(global::Windows.Devices.PointOfService.ClaimedPosPrinter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args)> ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMagneticStripeReaderEvents + { + private readonly global::Windows.Devices.PointOfService.MagneticStripeReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMagneticStripeReaderEvents(global::Windows.Devices.PointOfService.MagneticStripeReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPosPrinterEvents + { + private readonly global::Windows.Devices.PointOfService.PosPrinter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPosPrinterEvents(global::Windows.Devices.PointOfService.PosPrinter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + } +} + +namespace Windows.Devices.PointOfService.Provider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBarcodeScannerFrameReaderEvents Events(this global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader item) => new RxBarcodeScannerFrameReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBarcodeScannerProviderConnectionEvents Events(this global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection item) => new RxBarcodeScannerProviderConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBarcodeScannerFrameReaderEvents + { + private readonly global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBarcodeScannerFrameReaderEvents(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBarcodeScannerProviderConnectionEvents + { + private readonly global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBarcodeScannerProviderConnectionEvents(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args)> DisableScannerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisableScannerRequested += x, x => _data.DisableScannerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args)> EnableScannerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnableScannerRequested += x, x => _data.EnableScannerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args)> GetBarcodeSymbologyAttributesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GetBarcodeSymbologyAttributesRequested += x, x => _data.GetBarcodeSymbologyAttributesRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args)> HideVideoPreviewRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HideVideoPreviewRequested += x, x => _data.HideVideoPreviewRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args)> SetActiveSymbologiesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SetActiveSymbologiesRequested += x, x => _data.SetActiveSymbologiesRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args)> SetBarcodeSymbologyAttributesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SetBarcodeSymbologyAttributesRequested += x, x => _data.SetBarcodeSymbologyAttributesRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args)> StartSoftwareTriggerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StartSoftwareTriggerRequested += x, x => _data.StartSoftwareTriggerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args)> StopSoftwareTriggerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StopSoftwareTriggerRequested += x, x => _data.StopSoftwareTriggerRequested -= x); + } +} + +namespace Windows.Devices.Power +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBatteryEvents Events(this global::Windows.Devices.Power.Battery item) => new RxBatteryEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBatteryEvents + { + private readonly global::Windows.Devices.Power.Battery _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBatteryEvents(global::Windows.Devices.Power.Battery data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Power.Battery sender, object args)> ReportUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Power.Battery sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Power.Battery sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReportUpdated += x, x => _data.ReportUpdated -= x); + } +} + +namespace Windows.Devices.Printers.Extensions +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrint3DWorkflowEvents Events(this global::Windows.Devices.Printers.Extensions.Print3DWorkflow item) => new RxPrint3DWorkflowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintTaskConfigurationEvents Events(this global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration item) => new RxPrintTaskConfigurationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrint3DWorkflowEvents + { + private readonly global::Windows.Devices.Printers.Extensions.Print3DWorkflow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrint3DWorkflowEvents(global::Windows.Devices.Printers.Extensions.Print3DWorkflow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args)> PrinterChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrinterChanged += x, x => _data.PrinterChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args)> PrintRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrintRequested += x, x => _data.PrintRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintTaskConfigurationEvents + { + private readonly global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintTaskConfigurationEvents(global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration sender, global::Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequestedEventArgs args)> SaveRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration sender, global::Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration sender, global::Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SaveRequested += x, x => _data.SaveRequested -= x); + } +} + +namespace Windows.Devices.Radios +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioEvents Events(this global::Windows.Devices.Radios.Radio item) => new RxRadioEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioEvents + { + private readonly global::Windows.Devices.Radios.Radio _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioEvents(global::Windows.Devices.Radios.Radio data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Radios.Radio sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Radios.Radio sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Radios.Radio sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace Windows.Devices.Sensors +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAccelerometerEvents Events(this global::Windows.Devices.Sensors.Accelerometer item) => new RxAccelerometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxActivitySensorEvents Events(this global::Windows.Devices.Sensors.ActivitySensor item) => new RxActivitySensorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAltimeterEvents Events(this global::Windows.Devices.Sensors.Altimeter item) => new RxAltimeterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBarometerEvents Events(this global::Windows.Devices.Sensors.Barometer item) => new RxBarometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompassEvents Events(this global::Windows.Devices.Sensors.Compass item) => new RxCompassEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGyrometerEvents Events(this global::Windows.Devices.Sensors.Gyrometer item) => new RxGyrometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHingeAngleSensorEvents Events(this global::Windows.Devices.Sensors.HingeAngleSensor item) => new RxHingeAngleSensorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInclinometerEvents Events(this global::Windows.Devices.Sensors.Inclinometer item) => new RxInclinometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLightSensorEvents Events(this global::Windows.Devices.Sensors.LightSensor item) => new RxLightSensorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMagnetometerEvents Events(this global::Windows.Devices.Sensors.Magnetometer item) => new RxMagnetometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxOrientationSensorEvents Events(this global::Windows.Devices.Sensors.OrientationSensor item) => new RxOrientationSensorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPedometerEvents Events(this global::Windows.Devices.Sensors.Pedometer item) => new RxPedometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProximitySensorEvents Events(this global::Windows.Devices.Sensors.ProximitySensor item) => new RxProximitySensorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSimpleOrientationSensorEvents Events(this global::Windows.Devices.Sensors.SimpleOrientationSensor item) => new RxSimpleOrientationSensorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAccelerometerEvents + { + private readonly global::Windows.Devices.Sensors.Accelerometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAccelerometerEvents(global::Windows.Devices.Sensors.Accelerometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args)> Shaken => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Shaken += x, x => _data.Shaken -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxActivitySensorEvents + { + private readonly global::Windows.Devices.Sensors.ActivitySensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxActivitySensorEvents(global::Windows.Devices.Sensors.ActivitySensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAltimeterEvents + { + private readonly global::Windows.Devices.Sensors.Altimeter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAltimeterEvents(global::Windows.Devices.Sensors.Altimeter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBarometerEvents + { + private readonly global::Windows.Devices.Sensors.Barometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBarometerEvents(global::Windows.Devices.Sensors.Barometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompassEvents + { + private readonly global::Windows.Devices.Sensors.Compass _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompassEvents(global::Windows.Devices.Sensors.Compass data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGyrometerEvents + { + private readonly global::Windows.Devices.Sensors.Gyrometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGyrometerEvents(global::Windows.Devices.Sensors.Gyrometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHingeAngleSensorEvents + { + private readonly global::Windows.Devices.Sensors.HingeAngleSensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHingeAngleSensorEvents(global::Windows.Devices.Sensors.HingeAngleSensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInclinometerEvents + { + private readonly global::Windows.Devices.Sensors.Inclinometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInclinometerEvents(global::Windows.Devices.Sensors.Inclinometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLightSensorEvents + { + private readonly global::Windows.Devices.Sensors.LightSensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLightSensorEvents(global::Windows.Devices.Sensors.LightSensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMagnetometerEvents + { + private readonly global::Windows.Devices.Sensors.Magnetometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMagnetometerEvents(global::Windows.Devices.Sensors.Magnetometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxOrientationSensorEvents + { + private readonly global::Windows.Devices.Sensors.OrientationSensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxOrientationSensorEvents(global::Windows.Devices.Sensors.OrientationSensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPedometerEvents + { + private readonly global::Windows.Devices.Sensors.Pedometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPedometerEvents(global::Windows.Devices.Sensors.Pedometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProximitySensorEvents + { + private readonly global::Windows.Devices.Sensors.ProximitySensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProximitySensorEvents(global::Windows.Devices.Sensors.ProximitySensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSimpleOrientationSensorEvents + { + private readonly global::Windows.Devices.Sensors.SimpleOrientationSensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSimpleOrientationSensorEvents(global::Windows.Devices.Sensors.SimpleOrientationSensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args)> OrientationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + } +} + +namespace Windows.Devices.Sensors.Custom +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCustomSensorEvents Events(this global::Windows.Devices.Sensors.Custom.CustomSensor item) => new RxCustomSensorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCustomSensorEvents + { + private readonly global::Windows.Devices.Sensors.Custom.CustomSensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCustomSensorEvents(global::Windows.Devices.Sensors.Custom.CustomSensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } +} + +namespace Windows.Devices.SerialCommunication +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerialDeviceEvents Events(this global::Windows.Devices.SerialCommunication.SerialDevice item) => new RxSerialDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerialDeviceEvents + { + private readonly global::Windows.Devices.SerialCommunication.SerialDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerialDeviceEvents(global::Windows.Devices.SerialCommunication.SerialDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args)> ErrorReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorReceived += x, x => _data.ErrorReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args)> PinChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PinChanged += x, x => _data.PinChanged -= x); + } +} + +namespace Windows.Devices.SmartCards +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSmartCardEmulatorEvents Events(this global::Windows.Devices.SmartCards.SmartCardEmulator item) => new RxSmartCardEmulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSmartCardReaderEvents Events(this global::Windows.Devices.SmartCards.SmartCardReader item) => new RxSmartCardReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSmartCardEmulatorEvents + { + private readonly global::Windows.Devices.SmartCards.SmartCardEmulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSmartCardEmulatorEvents(global::Windows.Devices.SmartCards.SmartCardEmulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorApduReceivedEventArgs args)> ApduReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorApduReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorApduReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ApduReceived += x, x => _data.ApduReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorConnectionDeactivatedEventArgs args)> ConnectionDeactivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorConnectionDeactivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorConnectionDeactivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionDeactivated += x, x => _data.ConnectionDeactivated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSmartCardReaderEvents + { + private readonly global::Windows.Devices.SmartCards.SmartCardReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSmartCardReaderEvents(global::Windows.Devices.SmartCards.SmartCardReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args)> CardAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CardAdded += x, x => _data.CardAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args)> CardRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CardRemoved += x, x => _data.CardRemoved -= x); + } +} + +namespace Windows.Devices.Sms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxISmsDeviceEvents Events(this global::Windows.Devices.Sms.ISmsDevice item) => new RxISmsDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSmsDeviceEvents Events(this global::Windows.Devices.Sms.SmsDevice item) => new RxSmsDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSmsDevice2Events Events(this global::Windows.Devices.Sms.SmsDevice2 item) => new RxSmsDevice2Events(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSmsMessageRegistrationEvents Events(this global::Windows.Devices.Sms.SmsMessageRegistration item) => new RxSmsMessageRegistrationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxISmsDeviceEvents + { + private readonly global::Windows.Devices.Sms.ISmsDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxISmsDeviceEvents(global::Windows.Devices.Sms.ISmsDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SmsDeviceStatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsDevice sender) => eventHandler(sender); + return Handler; + }, x => _data.SmsDeviceStatusChanged += x, x => _data.SmsDeviceStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sms.SmsDevice sender, global::Windows.Devices.Sms.SmsMessageReceivedEventArgs e)> SmsMessageReceived => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsDevice sender, global::Windows.Devices.Sms.SmsMessageReceivedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.SmsMessageReceived += x, x => _data.SmsMessageReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSmsDeviceEvents + { + private readonly global::Windows.Devices.Sms.SmsDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSmsDeviceEvents(global::Windows.Devices.Sms.SmsDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SmsDeviceStatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsDevice sender) => eventHandler(sender); + return Handler; + }, x => _data.SmsDeviceStatusChanged += x, x => _data.SmsDeviceStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sms.SmsDevice sender, global::Windows.Devices.Sms.SmsMessageReceivedEventArgs e)> SmsMessageReceived => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsDevice sender, global::Windows.Devices.Sms.SmsMessageReceivedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.SmsMessageReceived += x, x => _data.SmsMessageReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSmsDevice2Events + { + private readonly global::Windows.Devices.Sms.SmsDevice2 _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSmsDevice2Events(global::Windows.Devices.Sms.SmsDevice2 data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sms.SmsDevice2 sender, object args)> DeviceStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sms.SmsDevice2 sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsDevice2 sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DeviceStatusChanged += x, x => _data.DeviceStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSmsMessageRegistrationEvents + { + private readonly global::Windows.Devices.Sms.SmsMessageRegistration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSmsMessageRegistrationEvents(global::Windows.Devices.Sms.SmsMessageRegistration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } +} + +namespace Windows.Devices.Usb +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUsbInterruptInPipeEvents Events(this global::Windows.Devices.Usb.UsbInterruptInPipe item) => new RxUsbInterruptInPipeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUsbInterruptInPipeEvents + { + private readonly global::Windows.Devices.Usb.UsbInterruptInPipe _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUsbInterruptInPipeEvents(global::Windows.Devices.Usb.UsbInterruptInPipe data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args)> DataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); + } +} + +namespace Windows.Devices.WiFi +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiAdapterEvents Events(this global::Windows.Devices.WiFi.WiFiAdapter item) => new RxWiFiAdapterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiAdapterEvents + { + private readonly global::Windows.Devices.WiFi.WiFiAdapter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiAdapterEvents(global::Windows.Devices.WiFi.WiFiAdapter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFi.WiFiAdapter sender, object args)> AvailableNetworksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFi.WiFiAdapter sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFi.WiFiAdapter sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailableNetworksChanged += x, x => _data.AvailableNetworksChanged -= x); + } +} + +namespace Windows.Devices.WiFiDirect +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectAdvertisementPublisherEvents Events(this global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher item) => new RxWiFiDirectAdvertisementPublisherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectConnectionListenerEvents Events(this global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener item) => new RxWiFiDirectConnectionListenerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectDeviceEvents Events(this global::Windows.Devices.WiFiDirect.WiFiDirectDevice item) => new RxWiFiDirectDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectAdvertisementPublisherEvents + { + private readonly global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectAdvertisementPublisherEvents(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectConnectionListenerEvents + { + private readonly global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectConnectionListenerEvents(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args)> ConnectionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectDeviceEvents + { + private readonly global::Windows.Devices.WiFiDirect.WiFiDirectDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectDeviceEvents(global::Windows.Devices.WiFiDirect.WiFiDirectDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args)> ConnectionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + } +} + +namespace Windows.Devices.WiFiDirect.Services +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectServiceEvents Events(this global::Windows.Devices.WiFiDirect.Services.WiFiDirectService item) => new RxWiFiDirectServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectServiceAdvertiserEvents Events(this global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser item) => new RxWiFiDirectServiceAdvertiserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectServiceSessionEvents Events(this global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession item) => new RxWiFiDirectServiceSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectServiceEvents + { + private readonly global::Windows.Devices.WiFiDirect.Services.WiFiDirectService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectServiceEvents(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args)> SessionDeferred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionDeferred += x, x => _data.SessionDeferred -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectServiceAdvertiserEvents + { + private readonly global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectServiceAdvertiserEvents(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args)> AdvertisementStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args)> AutoAcceptSessionConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutoAcceptSessionConnected += x, x => _data.AutoAcceptSessionConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args)> SessionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionRequested += x, x => _data.SessionRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectServiceSessionEvents + { + private readonly global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectServiceSessionEvents(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args)> RemotePortAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RemotePortAdded += x, x => _data.RemotePortAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args)> SessionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + } +} + +namespace Windows.Foundation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIMemoryBufferReferenceEvents Events(this global::Windows.Foundation.IMemoryBufferReference item) => new RxIMemoryBufferReferenceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIMemoryBufferReferenceEvents + { + private readonly global::Windows.Foundation.IMemoryBufferReference _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIMemoryBufferReferenceEvents(global::Windows.Foundation.IMemoryBufferReference data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.IMemoryBufferReference sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.IMemoryBufferReference sender, object args)>(eventHandler => + { + void Handler(global::Windows.Foundation.IMemoryBufferReference sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + } +} + +namespace Windows.Foundation.Collections +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertySetEvents Events(this global::Windows.Foundation.Collections.PropertySet item) => new RxPropertySetEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStringMapEvents Events(this global::Windows.Foundation.Collections.StringMap item) => new RxStringMapEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxValueSetEvents Events(this global::Windows.Foundation.Collections.ValueSet item) => new RxValueSetEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertySetEvents + { + private readonly global::Windows.Foundation.Collections.PropertySet _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertySetEvents(global::Windows.Foundation.Collections.PropertySet data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStringMapEvents + { + private readonly global::Windows.Foundation.Collections.StringMap _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStringMapEvents(global::Windows.Foundation.Collections.StringMap data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxValueSetEvents + { + private readonly global::Windows.Foundation.Collections.ValueSet _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxValueSetEvents(global::Windows.Foundation.Collections.ValueSet data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } +} + +namespace Windows.Foundation.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileLoggingSessionEvents Events(this global::Windows.Foundation.Diagnostics.FileLoggingSession item) => new RxFileLoggingSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIFileLoggingSessionEvents Events(this global::Windows.Foundation.Diagnostics.IFileLoggingSession item) => new RxIFileLoggingSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxILoggingChannelEvents Events(this global::Windows.Foundation.Diagnostics.ILoggingChannel item) => new RxILoggingChannelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLoggingChannelEvents Events(this global::Windows.Foundation.Diagnostics.LoggingChannel item) => new RxLoggingChannelEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileLoggingSessionEvents + { + private readonly global::Windows.Foundation.Diagnostics.FileLoggingSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileLoggingSessionEvents(global::Windows.Foundation.Diagnostics.FileLoggingSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)> LogFileGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIFileLoggingSessionEvents + { + private readonly global::Windows.Foundation.Diagnostics.IFileLoggingSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIFileLoggingSessionEvents(global::Windows.Foundation.Diagnostics.IFileLoggingSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)> LogFileGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxILoggingChannelEvents + { + private readonly global::Windows.Foundation.Diagnostics.ILoggingChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxILoggingChannelEvents(global::Windows.Foundation.Diagnostics.ILoggingChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)> LoggingEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)>(eventHandler => + { + void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLoggingChannelEvents + { + private readonly global::Windows.Foundation.Diagnostics.LoggingChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLoggingChannelEvents(global::Windows.Foundation.Diagnostics.LoggingChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)> LoggingEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)>(eventHandler => + { + void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + } +} + +namespace Windows.Gaming.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxArcadeStickEvents Events(this global::Windows.Gaming.Input.ArcadeStick item) => new RxArcadeStickEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFlightStickEvents Events(this global::Windows.Gaming.Input.FlightStick item) => new RxFlightStickEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGamepadEvents Events(this global::Windows.Gaming.Input.Gamepad item) => new RxGamepadEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIGameControllerEvents Events(this global::Windows.Gaming.Input.IGameController item) => new RxIGameControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRacingWheelEvents Events(this global::Windows.Gaming.Input.RacingWheel item) => new RxRacingWheelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRawGameControllerEvents Events(this global::Windows.Gaming.Input.RawGameController item) => new RxRawGameControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUINavigationControllerEvents Events(this global::Windows.Gaming.Input.UINavigationController item) => new RxUINavigationControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxArcadeStickEvents + { + private readonly global::Windows.Gaming.Input.ArcadeStick _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxArcadeStickEvents(global::Windows.Gaming.Input.ArcadeStick data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFlightStickEvents + { + private readonly global::Windows.Gaming.Input.FlightStick _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFlightStickEvents(global::Windows.Gaming.Input.FlightStick data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGamepadEvents + { + private readonly global::Windows.Gaming.Input.Gamepad _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGamepadEvents(global::Windows.Gaming.Input.Gamepad data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIGameControllerEvents + { + private readonly global::Windows.Gaming.Input.IGameController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIGameControllerEvents(global::Windows.Gaming.Input.IGameController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRacingWheelEvents + { + private readonly global::Windows.Gaming.Input.RacingWheel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRacingWheelEvents(global::Windows.Gaming.Input.RacingWheel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRawGameControllerEvents + { + private readonly global::Windows.Gaming.Input.RawGameController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRawGameControllerEvents(global::Windows.Gaming.Input.RawGameController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUINavigationControllerEvents + { + private readonly global::Windows.Gaming.Input.UINavigationController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUINavigationControllerEvents(global::Windows.Gaming.Input.UINavigationController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } +} + +namespace Windows.Gaming.UI +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGameChatOverlayMessageSourceEvents Events(this global::Windows.Gaming.UI.GameChatOverlayMessageSource item) => new RxGameChatOverlayMessageSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGameChatOverlayMessageSourceEvents + { + private readonly global::Windows.Gaming.UI.GameChatOverlayMessageSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGameChatOverlayMessageSourceEvents(global::Windows.Gaming.UI.GameChatOverlayMessageSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.UI.GameChatOverlayMessageSource sender, global::Windows.Gaming.UI.GameChatMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.UI.GameChatOverlayMessageSource sender, global::Windows.Gaming.UI.GameChatMessageReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.UI.GameChatOverlayMessageSource sender, global::Windows.Gaming.UI.GameChatMessageReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } +} + +namespace Windows.Graphics.Capture +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDirect3D11CaptureFramePoolEvents Events(this global::Windows.Graphics.Capture.Direct3D11CaptureFramePool item) => new RxDirect3D11CaptureFramePoolEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGraphicsCaptureItemEvents Events(this global::Windows.Graphics.Capture.GraphicsCaptureItem item) => new RxGraphicsCaptureItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDirect3D11CaptureFramePoolEvents + { + private readonly global::Windows.Graphics.Capture.Direct3D11CaptureFramePool _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDirect3D11CaptureFramePoolEvents(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGraphicsCaptureItemEvents + { + private readonly global::Windows.Graphics.Capture.GraphicsCaptureItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGraphicsCaptureItemEvents(global::Windows.Graphics.Capture.GraphicsCaptureItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + } +} + +namespace Windows.Graphics.Display +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBrightnessOverrideEvents Events(this global::Windows.Graphics.Display.BrightnessOverride item) => new RxBrightnessOverrideEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDisplayEnhancementOverrideEvents Events(this global::Windows.Graphics.Display.DisplayEnhancementOverride item) => new RxDisplayEnhancementOverrideEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDisplayInformationEvents Events(this global::Windows.Graphics.Display.DisplayInformation item) => new RxDisplayInformationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBrightnessOverrideEvents + { + private readonly global::Windows.Graphics.Display.BrightnessOverride _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBrightnessOverrideEvents(global::Windows.Graphics.Display.BrightnessOverride data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.BrightnessOverride sender, object args)> BrightnessLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.BrightnessOverride sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BrightnessLevelChanged += x, x => _data.BrightnessLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.BrightnessOverride sender, object args)> IsOverrideActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.BrightnessOverride sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.BrightnessOverride sender, object args)> IsSupportedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.BrightnessOverride sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDisplayEnhancementOverrideEvents + { + private readonly global::Windows.Graphics.Display.DisplayEnhancementOverride _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDisplayEnhancementOverrideEvents(global::Windows.Graphics.Display.DisplayEnhancementOverride data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)> CanOverrideChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CanOverrideChanged += x, x => _data.CanOverrideChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args)> DisplayEnhancementOverrideCapabilitiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisplayEnhancementOverrideCapabilitiesChanged += x, x => _data.DisplayEnhancementOverrideCapabilitiesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)> IsOverrideActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDisplayInformationEvents + { + private readonly global::Windows.Graphics.Display.DisplayInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDisplayInformationEvents(global::Windows.Graphics.Display.DisplayInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> AdvancedColorInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AdvancedColorInfoChanged += x, x => _data.AdvancedColorInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> ColorProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ColorProfileChanged += x, x => _data.ColorProfileChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> DpiChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> OrientationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> StereoEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StereoEnabledChanged += x, x => _data.StereoEnabledChanged -= x); + } +} + +namespace Windows.Graphics.Display.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHdmiDisplayInformationEvents Events(this global::Windows.Graphics.Display.Core.HdmiDisplayInformation item) => new RxHdmiDisplayInformationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHdmiDisplayInformationEvents + { + private readonly global::Windows.Graphics.Display.Core.HdmiDisplayInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHdmiDisplayInformationEvents(global::Windows.Graphics.Display.Core.HdmiDisplayInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args)> DisplayModesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisplayModesChanged += x, x => _data.DisplayModesChanged -= x); + } +} + +namespace Windows.Graphics.Holographic +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHolographicSpaceEvents Events(this global::Windows.Graphics.Holographic.HolographicSpace item) => new RxHolographicSpaceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHolographicSpaceEvents + { + private readonly global::Windows.Graphics.Holographic.HolographicSpace _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHolographicSpaceEvents(global::Windows.Graphics.Holographic.HolographicSpace data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args)> CameraAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraAdded += x, x => _data.CameraAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args)> CameraRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraRemoved += x, x => _data.CameraRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Holographic.HolographicSpace sender, object args)> UserPresenceChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Holographic.HolographicSpace sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserPresenceChanged += x, x => _data.UserPresenceChanged -= x); + } +} + +namespace Windows.Graphics.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintManagerEvents Events(this global::Windows.Graphics.Printing.PrintManager item) => new RxPrintManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintTaskEvents Events(this global::Windows.Graphics.Printing.PrintTask item) => new RxPrintTaskEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintManagerEvents + { + private readonly global::Windows.Graphics.Printing.PrintManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintManagerEvents(global::Windows.Graphics.Printing.PrintManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args)> PrintTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrintTaskRequested += x, x => _data.PrintTaskRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintTaskEvents + { + private readonly global::Windows.Graphics.Printing.PrintTask _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintTaskEvents(global::Windows.Graphics.Printing.PrintTask data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, object args)> Previewing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Previewing += x, x => _data.Previewing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args)> Progressing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Progressing += x, x => _data.Progressing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, object args)> Submitting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Submitting += x, x => _data.Submitting -= x); + } +} + +namespace Windows.Graphics.Printing.OptionDetails +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintTaskOptionDetailsEvents Events(this global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails item) => new RxPrintTaskOptionDetailsEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintTaskOptionDetailsEvents + { + private readonly global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintTaskOptionDetailsEvents(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args)> BeginValidation => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BeginValidation += x, x => _data.BeginValidation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args)> OptionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionChanged += x, x => _data.OptionChanged -= x); + } +} + +namespace Windows.Graphics.Printing.Workflow +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintWorkflowBackgroundSessionEvents Events(this global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession item) => new RxPrintWorkflowBackgroundSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintWorkflowForegroundSessionEvents Events(this global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession item) => new RxPrintWorkflowForegroundSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintWorkflowBackgroundSessionEvents + { + private readonly global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintWorkflowBackgroundSessionEvents(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args)> SetupRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args)> Submitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Submitted += x, x => _data.Submitted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintWorkflowForegroundSessionEvents + { + private readonly global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintWorkflowForegroundSessionEvents(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args)> SetupRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args)> XpsDataAvailable => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.XpsDataAvailable += x, x => _data.XpsDataAvailable -= x); + } +} + +namespace Windows.Graphics.Printing3D +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrint3DManagerEvents Events(this global::Windows.Graphics.Printing3D.Print3DManager item) => new RxPrint3DManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrint3DTaskEvents Events(this global::Windows.Graphics.Printing3D.Print3DTask item) => new RxPrint3DTaskEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrint3DManagerEvents + { + private readonly global::Windows.Graphics.Printing3D.Print3DManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrint3DManagerEvents(global::Windows.Graphics.Printing3D.Print3DManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing3D.Print3DManager sender, global::Windows.Graphics.Printing3D.Print3DTaskRequestedEventArgs args)> TaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing3D.Print3DManager sender, global::Windows.Graphics.Printing3D.Print3DTaskRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing3D.Print3DManager sender, global::Windows.Graphics.Printing3D.Print3DTaskRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TaskRequested += x, x => _data.TaskRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrint3DTaskEvents + { + private readonly global::Windows.Graphics.Printing3D.Print3DTask _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrint3DTaskEvents(global::Windows.Graphics.Printing3D.Print3DTask data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskSourceChangedEventArgs args)> SourceChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskSourceChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskSourceChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceChanged += x, x => _data.SourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing3D.Print3DTask sender, object args)> Submitting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing3D.Print3DTask sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing3D.Print3DTask sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Submitting += x, x => _data.Submitting -= x); + } +} + +namespace Windows.Management.Policies +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNamedPolicyDataEvents Events(this global::Windows.Management.Policies.NamedPolicyData item) => new RxNamedPolicyDataEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNamedPolicyDataEvents + { + private readonly global::Windows.Management.Policies.NamedPolicyData _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNamedPolicyDataEvents(global::Windows.Management.Policies.NamedPolicyData data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Management.Policies.NamedPolicyData sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Management.Policies.NamedPolicyData sender, object args)>(eventHandler => + { + void Handler(global::Windows.Management.Policies.NamedPolicyData sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaTimelineControllerEvents Events(this global::Windows.Media.MediaTimelineController item) => new RxMediaTimelineControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSystemMediaTransportControlsEvents Events(this global::Windows.Media.SystemMediaTransportControls item) => new RxSystemMediaTransportControlsEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaTimelineControllerEvents + { + private readonly global::Windows.Media.MediaTimelineController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaTimelineControllerEvents(global::Windows.Media.MediaTimelineController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, object args)> Ended => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Ended += x, x => _data.Ended -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args)> Failed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, object args)> PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSystemMediaTransportControlsEvents + { + private readonly global::Windows.Media.SystemMediaTransportControls _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSystemMediaTransportControlsEvents(global::Windows.Media.SystemMediaTransportControls data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args)> AutoRepeatModeChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutoRepeatModeChangeRequested += x, x => _data.AutoRepeatModeChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args)> ButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args)> PlaybackPositionChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackPositionChangeRequested += x, x => _data.PlaybackPositionChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args)> PlaybackRateChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args)> PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args)> ShuffleEnabledChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShuffleEnabledChangeRequested += x, x => _data.ShuffleEnabledChangeRequested -= x); + } +} + +namespace Windows.Media.AppBroadcasting +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastingMonitorEvents Events(this global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor item) => new RxAppBroadcastingMonitorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastingMonitorEvents + { + private readonly global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastingMonitorEvents(global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor sender, object args)> IsCurrentAppBroadcastingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsCurrentAppBroadcastingChanged += x, x => _data.IsCurrentAppBroadcastingChanged -= x); + } +} + +namespace Windows.Media.Audio +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioFileInputNodeEvents Events(this global::Windows.Media.Audio.AudioFileInputNode item) => new RxAudioFileInputNodeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioFrameInputNodeEvents Events(this global::Windows.Media.Audio.AudioFrameInputNode item) => new RxAudioFrameInputNodeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioGraphEvents Events(this global::Windows.Media.Audio.AudioGraph item) => new RxAudioGraphEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioPlaybackConnectionEvents Events(this global::Windows.Media.Audio.AudioPlaybackConnection item) => new RxAudioPlaybackConnectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioStateMonitorEvents Events(this global::Windows.Media.Audio.AudioStateMonitor item) => new RxAudioStateMonitorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaSourceAudioInputNodeEvents Events(this global::Windows.Media.Audio.MediaSourceAudioInputNode item) => new RxMediaSourceAudioInputNodeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialAudioDeviceConfigurationEvents Events(this global::Windows.Media.Audio.SpatialAudioDeviceConfiguration item) => new RxSpatialAudioDeviceConfigurationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioFileInputNodeEvents + { + private readonly global::Windows.Media.Audio.AudioFileInputNode _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioFileInputNodeEvents(global::Windows.Media.Audio.AudioFileInputNode data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioFileInputNode sender, object args)> FileCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioFileInputNode sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioFileInputNode sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FileCompleted += x, x => _data.FileCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioFrameInputNodeEvents + { + private readonly global::Windows.Media.Audio.AudioFrameInputNode _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioFrameInputNodeEvents(global::Windows.Media.Audio.AudioFrameInputNode data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args)> AudioFrameCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioFrameCompleted += x, x => _data.AudioFrameCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args)> QuantumStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioGraphEvents + { + private readonly global::Windows.Media.Audio.AudioGraph _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioGraphEvents(global::Windows.Media.Audio.AudioGraph data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioGraph sender, object args)> QuantumProcessed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioGraph sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuantumProcessed += x, x => _data.QuantumProcessed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioGraph sender, object args)> QuantumStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioGraph sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args)> UnrecoverableErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnrecoverableErrorOccurred += x, x => _data.UnrecoverableErrorOccurred -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioPlaybackConnectionEvents + { + private readonly global::Windows.Media.Audio.AudioPlaybackConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioPlaybackConnectionEvents(global::Windows.Media.Audio.AudioPlaybackConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioPlaybackConnection sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioPlaybackConnection sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioPlaybackConnection sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioStateMonitorEvents + { + private readonly global::Windows.Media.Audio.AudioStateMonitor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioStateMonitorEvents(global::Windows.Media.Audio.AudioStateMonitor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioStateMonitor sender, object args)> SoundLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioStateMonitor sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioStateMonitor sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SoundLevelChanged += x, x => _data.SoundLevelChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaSourceAudioInputNodeEvents + { + private readonly global::Windows.Media.Audio.MediaSourceAudioInputNode _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaSourceAudioInputNodeEvents(global::Windows.Media.Audio.MediaSourceAudioInputNode data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args)> MediaSourceCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaSourceCompleted += x, x => _data.MediaSourceCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialAudioDeviceConfigurationEvents + { + private readonly global::Windows.Media.Audio.SpatialAudioDeviceConfiguration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialAudioDeviceConfigurationEvents(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args)> ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + } +} + +namespace Windows.Media.Capture +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAdvancedPhotoCaptureEvents Events(this global::Windows.Media.Capture.AdvancedPhotoCapture item) => new RxAdvancedPhotoCaptureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastBackgroundServiceEvents Events(this global::Windows.Media.Capture.AppBroadcastBackgroundService item) => new RxAppBroadcastBackgroundServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastBackgroundServiceSignInInfoEvents Events(this global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo item) => new RxAppBroadcastBackgroundServiceSignInInfoEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastBackgroundServiceStreamInfoEvents Events(this global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo item) => new RxAppBroadcastBackgroundServiceStreamInfoEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastPreviewEvents Events(this global::Windows.Media.Capture.AppBroadcastPreview item) => new RxAppBroadcastPreviewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastPreviewStreamReaderEvents Events(this global::Windows.Media.Capture.AppBroadcastPreviewStreamReader item) => new RxAppBroadcastPreviewStreamReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastStateEvents Events(this global::Windows.Media.Capture.AppBroadcastState item) => new RxAppBroadcastStateEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastStreamReaderEvents Events(this global::Windows.Media.Capture.AppBroadcastStreamReader item) => new RxAppBroadcastStreamReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppCaptureEvents Events(this global::Windows.Media.Capture.AppCapture item) => new RxAppCaptureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppCaptureMetadataWriterEvents Events(this global::Windows.Media.Capture.AppCaptureMetadataWriter item) => new RxAppCaptureMetadataWriterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppCaptureRecordOperationEvents Events(this global::Windows.Media.Capture.AppCaptureRecordOperation item) => new RxAppCaptureRecordOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppCaptureStateEvents Events(this global::Windows.Media.Capture.AppCaptureState item) => new RxAppCaptureStateEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGameBarServicesEvents Events(this global::Windows.Media.Capture.GameBarServices item) => new RxGameBarServicesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGameBarServicesManagerEvents Events(this global::Windows.Media.Capture.GameBarServicesManager item) => new RxGameBarServicesManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLowLagPhotoSequenceCaptureEvents Events(this global::Windows.Media.Capture.LowLagPhotoSequenceCapture item) => new RxLowLagPhotoSequenceCaptureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaCaptureEvents Events(this global::Windows.Media.Capture.MediaCapture item) => new RxMediaCaptureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaCaptureRelativePanelWatcherEvents Events(this global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher item) => new RxMediaCaptureRelativePanelWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScreenCaptureEvents Events(this global::Windows.Media.Capture.ScreenCapture item) => new RxScreenCaptureEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAdvancedPhotoCaptureEvents + { + private readonly global::Windows.Media.Capture.AdvancedPhotoCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAdvancedPhotoCaptureEvents(global::Windows.Media.Capture.AdvancedPhotoCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args)> AllPhotosCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AllPhotosCaptured += x, x => _data.AllPhotosCaptured -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args)> OptionalReferencePhotoCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionalReferencePhotoCaptured += x, x => _data.OptionalReferencePhotoCaptured -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastBackgroundServiceEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastBackgroundService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastBackgroundServiceEvents(global::Windows.Media.Capture.AppBroadcastBackgroundService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)> BroadcastChannelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BroadcastChannelChanged += x, x => _data.BroadcastChannelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)> BroadcastLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BroadcastLanguageChanged += x, x => _data.BroadcastLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)> BroadcastTitleChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BroadcastTitleChanged += x, x => _data.BroadcastTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, global::Windows.Media.Capture.AppBroadcastHeartbeatRequestedEventArgs args)> HeartbeatRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundService sender, global::Windows.Media.Capture.AppBroadcastHeartbeatRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, global::Windows.Media.Capture.AppBroadcastHeartbeatRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeartbeatRequested += x, x => _data.HeartbeatRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastBackgroundServiceSignInInfoEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastBackgroundServiceSignInInfoEvents(global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, global::Windows.Media.Capture.AppBroadcastSignInStateChangedEventArgs args)> SignInStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, global::Windows.Media.Capture.AppBroadcastSignInStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, global::Windows.Media.Capture.AppBroadcastSignInStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SignInStateChanged += x, x => _data.SignInStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, object args)> UserNameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserNameChanged += x, x => _data.UserNameChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastBackgroundServiceStreamInfoEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastBackgroundServiceStreamInfoEvents(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args)> StreamStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StreamStateChanged += x, x => _data.StreamStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args)> VideoEncodingBitrateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoEncodingBitrateChanged += x, x => _data.VideoEncodingBitrateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args)> VideoEncodingResolutionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoEncodingResolutionChanged += x, x => _data.VideoEncodingResolutionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastPreviewEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastPreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastPreviewEvents(global::Windows.Media.Capture.AppBroadcastPreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastPreview sender, global::Windows.Media.Capture.AppBroadcastPreviewStateChangedEventArgs args)> PreviewStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastPreview sender, global::Windows.Media.Capture.AppBroadcastPreviewStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastPreview sender, global::Windows.Media.Capture.AppBroadcastPreviewStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PreviewStateChanged += x, x => _data.PreviewStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastPreviewStreamReaderEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastPreviewStreamReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastPreviewStreamReaderEvents(global::Windows.Media.Capture.AppBroadcastPreviewStreamReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastPreviewStreamReader sender, object args)> VideoFrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastPreviewStreamReader sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastPreviewStreamReader sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoFrameArrived += x, x => _data.VideoFrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastStateEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastState _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastStateEvents(global::Windows.Media.Capture.AppBroadcastState data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastCameraCaptureStateChangedEventArgs args)> CameraCaptureStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastCameraCaptureStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastCameraCaptureStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraCaptureStateChanged += x, x => _data.CameraCaptureStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, object args)> CaptureTargetClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CaptureTargetClosed += x, x => _data.CaptureTargetClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastMicrophoneCaptureStateChangedEventArgs args)> MicrophoneCaptureStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastMicrophoneCaptureStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastMicrophoneCaptureStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MicrophoneCaptureStateChanged += x, x => _data.MicrophoneCaptureStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastPlugInStateChangedEventArgs args)> PlugInStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastPlugInStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastPlugInStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlugInStateChanged += x, x => _data.PlugInStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args)> StreamStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StreamStateChanged += x, x => _data.StreamStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastViewerCountChangedEventArgs args)> ViewerCountChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastViewerCountChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastViewerCountChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ViewerCountChanged += x, x => _data.ViewerCountChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastStreamReaderEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastStreamReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastStreamReaderEvents(global::Windows.Media.Capture.AppBroadcastStreamReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args)> AudioFrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioFrameArrived += x, x => _data.AudioFrameArrived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args)> VideoFrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoFrameArrived += x, x => _data.VideoFrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppCaptureEvents + { + private readonly global::Windows.Media.Capture.AppCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppCaptureEvents(global::Windows.Media.Capture.AppCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCapture sender, object args)> CapturingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCapture sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCapture sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CapturingChanged += x, x => _data.CapturingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppCaptureMetadataWriterEvents + { + private readonly global::Windows.Media.Capture.AppCaptureMetadataWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppCaptureMetadataWriterEvents(global::Windows.Media.Capture.AppCaptureMetadataWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureMetadataWriter sender, object args)> MetadataPurged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureMetadataWriter sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureMetadataWriter sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MetadataPurged += x, x => _data.MetadataPurged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppCaptureRecordOperationEvents + { + private readonly global::Windows.Media.Capture.AppCaptureRecordOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppCaptureRecordOperationEvents(global::Windows.Media.Capture.AppCaptureRecordOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureDurationGeneratedEventArgs args)> DurationGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureDurationGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureDurationGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DurationGenerated += x, x => _data.DurationGenerated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureFileGeneratedEventArgs args)> FileGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureFileGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureFileGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FileGenerated += x, x => _data.FileGenerated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureRecordingStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureRecordingStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureRecordingStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppCaptureStateEvents + { + private readonly global::Windows.Media.Capture.AppCaptureState _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppCaptureStateEvents(global::Windows.Media.Capture.AppCaptureState data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureState sender, object args)> CaptureTargetClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureState sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureState sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CaptureTargetClosed += x, x => _data.CaptureTargetClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureState sender, global::Windows.Media.Capture.AppCaptureMicrophoneCaptureStateChangedEventArgs args)> MicrophoneCaptureStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureState sender, global::Windows.Media.Capture.AppCaptureMicrophoneCaptureStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureState sender, global::Windows.Media.Capture.AppCaptureMicrophoneCaptureStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MicrophoneCaptureStateChanged += x, x => _data.MicrophoneCaptureStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGameBarServicesEvents + { + private readonly global::Windows.Media.Capture.GameBarServices _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGameBarServicesEvents(global::Windows.Media.Capture.GameBarServices data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.GameBarServices sender, global::Windows.Media.Capture.GameBarServicesCommandEventArgs args)> CommandReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.GameBarServices sender, global::Windows.Media.Capture.GameBarServicesCommandEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.GameBarServices sender, global::Windows.Media.Capture.GameBarServicesCommandEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CommandReceived += x, x => _data.CommandReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGameBarServicesManagerEvents + { + private readonly global::Windows.Media.Capture.GameBarServicesManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGameBarServicesManagerEvents(global::Windows.Media.Capture.GameBarServicesManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.GameBarServicesManager sender, global::Windows.Media.Capture.GameBarServicesManagerGameBarServicesCreatedEventArgs args)> GameBarServicesCreated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.GameBarServicesManager sender, global::Windows.Media.Capture.GameBarServicesManagerGameBarServicesCreatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.GameBarServicesManager sender, global::Windows.Media.Capture.GameBarServicesManagerGameBarServicesCreatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GameBarServicesCreated += x, x => _data.GameBarServicesCreated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLowLagPhotoSequenceCaptureEvents + { + private readonly global::Windows.Media.Capture.LowLagPhotoSequenceCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLowLagPhotoSequenceCaptureEvents(global::Windows.Media.Capture.LowLagPhotoSequenceCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args)> PhotoCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaCaptureEvents + { + private readonly global::Windows.Media.Capture.MediaCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaCaptureEvents(global::Windows.Media.Capture.MediaCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, object args)> CameraStreamStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraStreamStateChanged += x, x => _data.CameraStreamStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args)> CaptureDeviceExclusiveControlStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CaptureDeviceExclusiveControlStatusChanged += x, x => _data.CaptureDeviceExclusiveControlStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFailedEventArgs errorEventArgs)> Failed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFailedEventArgs errorEventArgs) => eventHandler((sender, errorEventArgs)); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args)> FocusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FocusChanged += x, x => _data.FocusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args)> PhotoConfirmationCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PhotoConfirmationCaptured += x, x => _data.PhotoConfirmationCaptured -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecordLimitationExceeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender) => eventHandler(sender); + return Handler; + }, x => _data.RecordLimitationExceeded += x, x => _data.RecordLimitationExceeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, object args)> ThermalStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ThermalStatusChanged += x, x => _data.ThermalStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaCaptureRelativePanelWatcherEvents + { + private readonly global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaCaptureRelativePanelWatcherEvents(global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScreenCaptureEvents + { + private readonly global::Windows.Media.Capture.ScreenCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScreenCaptureEvents(global::Windows.Media.Capture.ScreenCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args)> SourceSuspensionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceSuspensionChanged += x, x => _data.SourceSuspensionChanged -= x); + } +} + +namespace Windows.Media.Capture.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVariablePhotoSequenceCaptureEvents Events(this global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture item) => new RxVariablePhotoSequenceCaptureEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVariablePhotoSequenceCaptureEvents + { + private readonly global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVariablePhotoSequenceCaptureEvents(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args)> PhotoCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } +} + +namespace Windows.Media.Capture.Frames +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaFrameReaderEvents Events(this global::Windows.Media.Capture.Frames.MediaFrameReader item) => new RxMediaFrameReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaFrameSourceEvents Events(this global::Windows.Media.Capture.Frames.MediaFrameSource item) => new RxMediaFrameSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMultiSourceMediaFrameReaderEvents Events(this global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader item) => new RxMultiSourceMediaFrameReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaFrameReaderEvents + { + private readonly global::Windows.Media.Capture.Frames.MediaFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaFrameReaderEvents(global::Windows.Media.Capture.Frames.MediaFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaFrameSourceEvents + { + private readonly global::Windows.Media.Capture.Frames.MediaFrameSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaFrameSourceEvents(global::Windows.Media.Capture.Frames.MediaFrameSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args)> FormatChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMultiSourceMediaFrameReaderEvents + { + private readonly global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMultiSourceMediaFrameReaderEvents(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } +} + +namespace Windows.Media.Casting +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCastingConnectionEvents Events(this global::Windows.Media.Casting.CastingConnection item) => new RxCastingConnectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCastingDevicePickerEvents Events(this global::Windows.Media.Casting.CastingDevicePicker item) => new RxCastingDevicePickerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCastingConnectionEvents + { + private readonly global::Windows.Media.Casting.CastingConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCastingConnectionEvents(global::Windows.Media.Casting.CastingConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Casting.CastingConnection sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingConnection sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Casting.CastingConnection sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCastingDevicePickerEvents + { + private readonly global::Windows.Media.Casting.CastingDevicePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCastingDevicePickerEvents(global::Windows.Media.Casting.CastingDevicePicker data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Casting.CastingDevicePicker sender, object args)> CastingDevicePickerDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingDevicePicker sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CastingDevicePickerDismissed += x, x => _data.CastingDevicePickerDismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args)> CastingDeviceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CastingDeviceSelected += x, x => _data.CastingDeviceSelected -= x); + } +} + +namespace Windows.Media.ContentRestrictions +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRatedContentRestrictionsEvents Events(this global::Windows.Media.ContentRestrictions.RatedContentRestrictions item) => new RxRatedContentRestrictionsEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRatedContentRestrictionsEvents + { + private readonly global::Windows.Media.ContentRestrictions.RatedContentRestrictions _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRatedContentRestrictionsEvents(global::Windows.Media.ContentRestrictions.RatedContentRestrictions data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RestrictionsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.RestrictionsChanged += x, x => _data.RestrictionsChanged -= x); + } +} + +namespace Windows.Media.Control +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGlobalSystemMediaTransportControlsSessionEvents Events(this global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession item) => new RxGlobalSystemMediaTransportControlsSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGlobalSystemMediaTransportControlsSessionManagerEvents Events(this global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager item) => new RxGlobalSystemMediaTransportControlsSessionManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGlobalSystemMediaTransportControlsSessionEvents + { + private readonly global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGlobalSystemMediaTransportControlsSessionEvents(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args)> MediaPropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaPropertiesChanged += x, x => _data.MediaPropertiesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args)> PlaybackInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackInfoChanged += x, x => _data.PlaybackInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args)> TimelinePropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TimelinePropertiesChanged += x, x => _data.TimelinePropertiesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGlobalSystemMediaTransportControlsSessionManagerEvents + { + private readonly global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGlobalSystemMediaTransportControlsSessionManagerEvents(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args)> CurrentSessionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CurrentSessionChanged += x, x => _data.CurrentSessionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args)> SessionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionsChanged += x, x => _data.SessionsChanged -= x); + } +} + +namespace Windows.Media.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioTrackEvents Events(this global::Windows.Media.Core.AudioTrack item) => new RxAudioTrackEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFaceDetectionEffectEvents Events(this global::Windows.Media.Core.FaceDetectionEffect item) => new RxFaceDetectionEffectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxISingleSelectMediaTrackListEvents Events(this global::Windows.Media.Core.ISingleSelectMediaTrackList item) => new RxISingleSelectMediaTrackListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaBinderEvents Events(this global::Windows.Media.Core.MediaBinder item) => new RxMediaBinderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaBindingEventArgsEvents Events(this global::Windows.Media.Core.MediaBindingEventArgs item) => new RxMediaBindingEventArgsEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaSourceEvents Events(this global::Windows.Media.Core.MediaSource item) => new RxMediaSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaSourceAppServiceConnectionEvents Events(this global::Windows.Media.Core.MediaSourceAppServiceConnection item) => new RxMediaSourceAppServiceConnectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaStreamSampleEvents Events(this global::Windows.Media.Core.MediaStreamSample item) => new RxMediaStreamSampleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaStreamSourceEvents Events(this global::Windows.Media.Core.MediaStreamSource item) => new RxMediaStreamSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMseSourceBufferEvents Events(this global::Windows.Media.Core.MseSourceBuffer item) => new RxMseSourceBufferEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMseSourceBufferListEvents Events(this global::Windows.Media.Core.MseSourceBufferList item) => new RxMseSourceBufferListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMseStreamSourceEvents Events(this global::Windows.Media.Core.MseStreamSource item) => new RxMseStreamSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSceneAnalysisEffectEvents Events(this global::Windows.Media.Core.SceneAnalysisEffect item) => new RxSceneAnalysisEffectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimedMetadataTrackEvents Events(this global::Windows.Media.Core.TimedMetadataTrack item) => new RxTimedMetadataTrackEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimedTextSourceEvents Events(this global::Windows.Media.Core.TimedTextSource item) => new RxTimedTextSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVideoStabilizationEffectEvents Events(this global::Windows.Media.Core.VideoStabilizationEffect item) => new RxVideoStabilizationEffectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVideoTrackEvents Events(this global::Windows.Media.Core.VideoTrack item) => new RxVideoTrackEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioTrackEvents + { + private readonly global::Windows.Media.Core.AudioTrack _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioTrackEvents(global::Windows.Media.Core.AudioTrack data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args)> OpenFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFaceDetectionEffectEvents + { + private readonly global::Windows.Media.Core.FaceDetectionEffect _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFaceDetectionEffectEvents(global::Windows.Media.Core.FaceDetectionEffect data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args)> FaceDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FaceDetected += x, x => _data.FaceDetected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxISingleSelectMediaTrackListEvents + { + private readonly global::Windows.Media.Core.ISingleSelectMediaTrackList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxISingleSelectMediaTrackListEvents(global::Windows.Media.Core.ISingleSelectMediaTrackList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)> SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaBinderEvents + { + private readonly global::Windows.Media.Core.MediaBinder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaBinderEvents(global::Windows.Media.Core.MediaBinder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args)> Binding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Binding += x, x => _data.Binding -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaBindingEventArgsEvents + { + private readonly global::Windows.Media.Core.MediaBindingEventArgs _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaBindingEventArgsEvents(global::Windows.Media.Core.MediaBindingEventArgs data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaBindingEventArgs sender, object args)> Canceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaBindingEventArgs sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaBindingEventArgs sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Canceled += x, x => _data.Canceled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaSourceEvents + { + private readonly global::Windows.Media.Core.MediaSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaSourceEvents(global::Windows.Media.Core.MediaSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args)> OpenOperationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OpenOperationCompleted += x, x => _data.OpenOperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaSourceAppServiceConnectionEvents + { + private readonly global::Windows.Media.Core.MediaSourceAppServiceConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaSourceAppServiceConnectionEvents(global::Windows.Media.Core.MediaSourceAppServiceConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args)> InitializeMediaStreamSourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InitializeMediaStreamSourceRequested += x, x => _data.InitializeMediaStreamSourceRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaStreamSampleEvents + { + private readonly global::Windows.Media.Core.MediaStreamSample _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaStreamSampleEvents(global::Windows.Media.Core.MediaStreamSample data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSample sender, object args)> Processed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSample sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSample sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Processed += x, x => _data.Processed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaStreamSourceEvents + { + private readonly global::Windows.Media.Core.MediaStreamSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaStreamSourceEvents(global::Windows.Media.Core.MediaStreamSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, object args)> Paused => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Paused += x, x => _data.Paused -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args)> SampleRendered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SampleRendered += x, x => _data.SampleRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args)> SampleRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SampleRequested += x, x => _data.SampleRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args)> Starting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Starting += x, x => _data.Starting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args)> SwitchStreamsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SwitchStreamsRequested += x, x => _data.SwitchStreamsRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMseSourceBufferEvents + { + private readonly global::Windows.Media.Core.MseSourceBuffer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMseSourceBufferEvents(global::Windows.Media.Core.MseSourceBuffer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> Aborted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> UpdateEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UpdateEnded += x, x => _data.UpdateEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> UpdateStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UpdateStarting += x, x => _data.UpdateStarting -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMseSourceBufferListEvents + { + private readonly global::Windows.Media.Core.MseSourceBufferList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMseSourceBufferListEvents(global::Windows.Media.Core.MseSourceBufferList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBufferList sender, object args)> SourceBufferAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBufferList sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceBufferAdded += x, x => _data.SourceBufferAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBufferList sender, object args)> SourceBufferRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBufferList sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceBufferRemoved += x, x => _data.SourceBufferRemoved -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMseStreamSourceEvents + { + private readonly global::Windows.Media.Core.MseStreamSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMseStreamSourceEvents(global::Windows.Media.Core.MseStreamSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseStreamSource sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseStreamSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseStreamSource sender, object args)> Ended => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseStreamSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Ended += x, x => _data.Ended -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseStreamSource sender, object args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseStreamSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSceneAnalysisEffectEvents + { + private readonly global::Windows.Media.Core.SceneAnalysisEffect _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSceneAnalysisEffectEvents(global::Windows.Media.Core.SceneAnalysisEffect data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args)> SceneAnalyzed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SceneAnalyzed += x, x => _data.SceneAnalyzed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimedMetadataTrackEvents + { + private readonly global::Windows.Media.Core.TimedMetadataTrack _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimedMetadataTrackEvents(global::Windows.Media.Core.TimedMetadataTrack data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)> CueEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CueEntered += x, x => _data.CueEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)> CueExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CueExited += x, x => _data.CueExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args)> TrackFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TrackFailed += x, x => _data.TrackFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimedTextSourceEvents + { + private readonly global::Windows.Media.Core.TimedTextSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimedTextSourceEvents(global::Windows.Media.Core.TimedTextSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args)> Resolved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Resolved += x, x => _data.Resolved -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVideoStabilizationEffectEvents + { + private readonly global::Windows.Media.Core.VideoStabilizationEffect _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVideoStabilizationEffectEvents(global::Windows.Media.Core.VideoStabilizationEffect data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args)> EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVideoTrackEvents + { + private readonly global::Windows.Media.Core.VideoTrack _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVideoTrackEvents(global::Windows.Media.Core.VideoTrack data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args)> OpenFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + } +} + +namespace Windows.Media.Devices +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioDeviceModulesManagerEvents Events(this global::Windows.Media.Devices.AudioDeviceModulesManager item) => new RxAudioDeviceModulesManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCallControlEvents Events(this global::Windows.Media.Devices.CallControl item) => new RxCallControlEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioDeviceModulesManagerEvents + { + private readonly global::Windows.Media.Devices.AudioDeviceModulesManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioDeviceModulesManagerEvents(global::Windows.Media.Devices.AudioDeviceModulesManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args)> ModuleNotificationReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ModuleNotificationReceived += x, x => _data.ModuleNotificationReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCallControlEvents + { + private readonly global::Windows.Media.Devices.CallControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCallControlEvents(global::Windows.Media.Devices.CallControl data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnswerRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender) => eventHandler(sender); + return Handler; + }, x => _data.AnswerRequested += x, x => _data.AnswerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AudioTransferRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender) => eventHandler(sender); + return Handler; + }, x => _data.AudioTransferRequested += x, x => _data.AudioTransferRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.DialRequestedEventArgs e)> DialRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.DialRequestedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.DialRequested += x, x => _data.DialRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HangUpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender) => eventHandler(sender); + return Handler; + }, x => _data.HangUpRequested += x, x => _data.HangUpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.KeypadPressedEventArgs e)> KeypadPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.KeypadPressedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.KeypadPressed += x, x => _data.KeypadPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.RedialRequestedEventArgs e)> RedialRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.RedialRequestedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.RedialRequested += x, x => _data.RedialRequested -= x); + } +} + +namespace Windows.Media.DialProtocol +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDialDevicePickerEvents Events(this global::Windows.Media.DialProtocol.DialDevicePicker item) => new RxDialDevicePickerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDialDevicePickerEvents + { + private readonly global::Windows.Media.DialProtocol.DialDevicePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDialDevicePickerEvents(global::Windows.Media.DialProtocol.DialDevicePicker data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.DialProtocol.DialDevicePicker sender, object args)> DialDevicePickerDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.DialProtocol.DialDevicePicker sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DialDevicePickerDismissed += x, x => _data.DialDevicePickerDismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args)> DialDeviceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DialDeviceSelected += x, x => _data.DialDeviceSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args)> DisconnectButtonClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + } +} + +namespace Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioCaptureEffectsManagerEvents Events(this global::Windows.Media.Effects.AudioCaptureEffectsManager item) => new RxAudioCaptureEffectsManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioRenderEffectsManagerEvents Events(this global::Windows.Media.Effects.AudioRenderEffectsManager item) => new RxAudioRenderEffectsManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioCaptureEffectsManagerEvents + { + private readonly global::Windows.Media.Effects.AudioCaptureEffectsManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioCaptureEffectsManagerEvents(global::Windows.Media.Effects.AudioCaptureEffectsManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args)> AudioCaptureEffectsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioCaptureEffectsChanged += x, x => _data.AudioCaptureEffectsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioRenderEffectsManagerEvents + { + private readonly global::Windows.Media.Effects.AudioRenderEffectsManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioRenderEffectsManagerEvents(global::Windows.Media.Effects.AudioRenderEffectsManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args)> AudioRenderEffectsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioRenderEffectsChanged += x, x => _data.AudioRenderEffectsChanged -= x); + } +} + +namespace Windows.Media.Import +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPhotoImportFindItemsResultEvents Events(this global::Windows.Media.Import.PhotoImportFindItemsResult item) => new RxPhotoImportFindItemsResultEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPhotoImportFindItemsResultEvents + { + private readonly global::Windows.Media.Import.PhotoImportFindItemsResult _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPhotoImportFindItemsResultEvents(global::Windows.Media.Import.PhotoImportFindItemsResult data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args)> ItemImported => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemImported += x, x => _data.ItemImported -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args)> SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } +} + +namespace Windows.Media.Miracast +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMiracastReceiverEvents Events(this global::Windows.Media.Miracast.MiracastReceiver item) => new RxMiracastReceiverEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMiracastReceiverCursorImageChannelEvents Events(this global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel item) => new RxMiracastReceiverCursorImageChannelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMiracastReceiverGameControllerDeviceEvents Events(this global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice item) => new RxMiracastReceiverGameControllerDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMiracastReceiverKeyboardDeviceEvents Events(this global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice item) => new RxMiracastReceiverKeyboardDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMiracastReceiverSessionEvents Events(this global::Windows.Media.Miracast.MiracastReceiverSession item) => new RxMiracastReceiverSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMiracastReceiverEvents + { + private readonly global::Windows.Media.Miracast.MiracastReceiver _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMiracastReceiverEvents(global::Windows.Media.Miracast.MiracastReceiver data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiver sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMiracastReceiverCursorImageChannelEvents + { + private readonly global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMiracastReceiverCursorImageChannelEvents(global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args)> ImageStreamChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ImageStreamChanged += x, x => _data.ImageStreamChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args)> PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMiracastReceiverGameControllerDeviceEvents + { + private readonly global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMiracastReceiverGameControllerDeviceEvents(global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMiracastReceiverKeyboardDeviceEvents + { + private readonly global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMiracastReceiverKeyboardDeviceEvents(global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMiracastReceiverSessionEvents + { + private readonly global::Windows.Media.Miracast.MiracastReceiverSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMiracastReceiverSessionEvents(global::Windows.Media.Miracast.MiracastReceiverSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverConnectionCreatedEventArgs args)> ConnectionCreated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverConnectionCreatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverConnectionCreatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionCreated += x, x => _data.ConnectionCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverDisconnectedEventArgs args)> Disconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverDisconnectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverDisconnectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Disconnected += x, x => _data.Disconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverMediaSourceCreatedEventArgs args)> MediaSourceCreated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverMediaSourceCreatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverMediaSourceCreatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaSourceCreated += x, x => _data.MediaSourceCreated -= x); + } +} + +namespace Windows.Media.Playback +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaBreakManagerEvents Events(this global::Windows.Media.Playback.MediaBreakManager item) => new RxMediaBreakManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaBreakScheduleEvents Events(this global::Windows.Media.Playback.MediaBreakSchedule item) => new RxMediaBreakScheduleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackAudioTrackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackAudioTrackList item) => new RxMediaPlaybackAudioTrackListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackCommandManagerEvents Events(this global::Windows.Media.Playback.MediaPlaybackCommandManager item) => new RxMediaPlaybackCommandManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackCommandManagerCommandBehaviorEvents Events(this global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior item) => new RxMediaPlaybackCommandManagerCommandBehaviorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackItemEvents Events(this global::Windows.Media.Playback.MediaPlaybackItem item) => new RxMediaPlaybackItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackList item) => new RxMediaPlaybackListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackSessionEvents Events(this global::Windows.Media.Playback.MediaPlaybackSession item) => new RxMediaPlaybackSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackTimedMetadataTrackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList item) => new RxMediaPlaybackTimedMetadataTrackListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackVideoTrackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackVideoTrackList item) => new RxMediaPlaybackVideoTrackListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::Windows.Media.Playback.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaBreakManagerEvents + { + private readonly global::Windows.Media.Playback.MediaBreakManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaBreakManagerEvents(global::Windows.Media.Playback.MediaBreakManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args)> BreakEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BreakEnded += x, x => _data.BreakEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args)> BreakSkipped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BreakSkipped += x, x => _data.BreakSkipped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args)> BreaksSeekedOver => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BreaksSeekedOver += x, x => _data.BreaksSeekedOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args)> BreakStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BreakStarted += x, x => _data.BreakStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaBreakScheduleEvents + { + private readonly global::Windows.Media.Playback.MediaBreakSchedule _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaBreakScheduleEvents(global::Windows.Media.Playback.MediaBreakSchedule data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakSchedule sender, object args)> ScheduleChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakSchedule sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaBreakSchedule sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScheduleChanged += x, x => _data.ScheduleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackAudioTrackListEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackAudioTrackList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackAudioTrackListEvents(global::Windows.Media.Playback.MediaPlaybackAudioTrackList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)> SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackCommandManagerEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackCommandManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackCommandManagerEvents(global::Windows.Media.Playback.MediaPlaybackCommandManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args)> AutoRepeatModeReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutoRepeatModeReceived += x, x => _data.AutoRepeatModeReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args)> FastForwardReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FastForwardReceived += x, x => _data.FastForwardReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args)> NextReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NextReceived += x, x => _data.NextReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args)> PauseReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PauseReceived += x, x => _data.PauseReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args)> PlayReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlayReceived += x, x => _data.PlayReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args)> PositionReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionReceived += x, x => _data.PositionReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args)> PreviousReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PreviousReceived += x, x => _data.PreviousReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args)> RateReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RateReceived += x, x => _data.RateReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args)> RewindReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RewindReceived += x, x => _data.RewindReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args)> ShuffleReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShuffleReceived += x, x => _data.ShuffleReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackCommandManagerCommandBehaviorEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackCommandManagerCommandBehaviorEvents(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args)> IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackItemEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackItemEvents(global::Windows.Media.Playback.MediaPlaybackItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)> AudioTracksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioTracksChanged += x, x => _data.AudioTracksChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)> TimedMetadataTracksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TimedMetadataTracksChanged += x, x => _data.TimedMetadataTracksChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)> VideoTracksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoTracksChanged += x, x => _data.VideoTracksChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackListEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackListEvents(global::Windows.Media.Playback.MediaPlaybackList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args)> CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args)> ItemFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemFailed += x, x => _data.ItemFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args)> ItemOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemOpened += x, x => _data.ItemOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackSessionEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackSessionEvents(global::Windows.Media.Playback.MediaPlaybackSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferedRangesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferedRangesChanged += x, x => _data.BufferedRangesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> DownloadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> NaturalDurationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NaturalDurationChanged += x, x => _data.NaturalDurationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> NaturalVideoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NaturalVideoSizeChanged += x, x => _data.NaturalVideoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PlaybackRateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackRateChanged += x, x => _data.PlaybackRateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PlaybackStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackStateChanged += x, x => _data.PlaybackStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PlayedRangesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlayedRangesChanged += x, x => _data.PlayedRangesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> SeekableRangesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SeekableRangesChanged += x, x => _data.SeekableRangesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> SeekCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> SupportedPlaybackRatesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SupportedPlaybackRatesChanged += x, x => _data.SupportedPlaybackRatesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackTimedMetadataTrackListEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackTimedMetadataTrackListEvents(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args)> PresentationModeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PresentationModeChanged += x, x => _data.PresentationModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackVideoTrackListEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackVideoTrackList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackVideoTrackListEvents(global::Windows.Media.Playback.MediaPlaybackVideoTrackList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)> SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents + { + private readonly global::Windows.Media.Playback.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::Windows.Media.Playback.MediaPlayer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> IsMutedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsMutedChanged += x, x => _data.IsMutedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> MediaEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args)> MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> MediaOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args)> MediaPlayerRateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaPlayerRateChanged += x, x => _data.MediaPlayerRateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args)> PlaybackMediaMarkerReached => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackMediaMarkerReached += x, x => _data.PlaybackMediaMarkerReached -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> SeekCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> SourceChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceChanged += x, x => _data.SourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> SubtitleFrameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SubtitleFrameChanged += x, x => _data.SubtitleFrameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> VideoFrameAvailable => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoFrameAvailable += x, x => _data.VideoFrameAvailable -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> VolumeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + } +} + +namespace Windows.Media.PlayTo +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPlayToConnectionEvents Events(this global::Windows.Media.PlayTo.PlayToConnection item) => new RxPlayToConnectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPlayToManagerEvents Events(this global::Windows.Media.PlayTo.PlayToManager item) => new RxPlayToManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPlayToReceiverEvents Events(this global::Windows.Media.PlayTo.PlayToReceiver item) => new RxPlayToReceiverEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPlayToConnectionEvents + { + private readonly global::Windows.Media.PlayTo.PlayToConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPlayToConnectionEvents(global::Windows.Media.PlayTo.PlayToConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args)> Error => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args)> Transferred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Transferred += x, x => _data.Transferred -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPlayToManagerEvents + { + private readonly global::Windows.Media.PlayTo.PlayToManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPlayToManagerEvents(global::Windows.Media.PlayTo.PlayToManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args)> SourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceRequested += x, x => _data.SourceRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args)> SourceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceSelected += x, x => _data.SourceSelected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPlayToReceiverEvents + { + private readonly global::Windows.Media.PlayTo.PlayToReceiver _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPlayToReceiverEvents(global::Windows.Media.PlayTo.PlayToReceiver data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args)> CurrentTimeChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CurrentTimeChangeRequested += x, x => _data.CurrentTimeChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args)> MuteChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MuteChangeRequested += x, x => _data.MuteChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> PauseRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PauseRequested += x, x => _data.PauseRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args)> PlaybackRateChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> PlayRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlayRequested += x, x => _data.PlayRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args)> SourceChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceChangeRequested += x, x => _data.SourceChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> StopRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StopRequested += x, x => _data.StopRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> TimeUpdateRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TimeUpdateRequested += x, x => _data.TimeUpdateRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args)> VolumeChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VolumeChangeRequested += x, x => _data.VolumeChangeRequested -= x); + } +} + +namespace Windows.Media.Protection +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHdcpSessionEvents Events(this global::Windows.Media.Protection.HdcpSession item) => new RxHdcpSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaProtectionManagerEvents Events(this global::Windows.Media.Protection.MediaProtectionManager item) => new RxMediaProtectionManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHdcpSessionEvents + { + private readonly global::Windows.Media.Protection.HdcpSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHdcpSessionEvents(global::Windows.Media.Protection.HdcpSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.HdcpSession sender, object args)> ProtectionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.HdcpSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.HdcpSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProtectionChanged += x, x => _data.ProtectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaProtectionManagerEvents + { + private readonly global::Windows.Media.Protection.MediaProtectionManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaProtectionManagerEvents(global::Windows.Media.Protection.MediaProtectionManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ComponentLoadFailedEventArgs e)> ComponentLoadFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ComponentLoadFailedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.ComponentLoadFailed += x, x => _data.ComponentLoadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RebootNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Protection.MediaProtectionManager sender) => eventHandler(sender); + return Handler; + }, x => _data.RebootNeeded += x, x => _data.RebootNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ServiceRequestedEventArgs e)> ServiceRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ServiceRequestedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.ServiceRequested += x, x => _data.ServiceRequested -= x); + } +} + +namespace Windows.Media.Protection.PlayReady +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNDClientEvents Events(this global::Windows.Media.Protection.PlayReady.NDClient item) => new RxNDClientEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNDClientEvents + { + private readonly global::Windows.Media.Protection.PlayReady.NDClient _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNDClientEvents(global::Windows.Media.Protection.PlayReady.NDClient data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args)> ClosedCaptionDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ClosedCaptionDataReceived += x, x => _data.ClosedCaptionDataReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args)> LicenseFetchCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LicenseFetchCompleted += x, x => _data.LicenseFetchCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args)> ProximityDetectionCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProximityDetectionCompleted += x, x => _data.ProximityDetectionCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args)> RegistrationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RegistrationCompleted += x, x => _data.RegistrationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, object args)> ReRegistrationNeeded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReRegistrationNeeded += x, x => _data.ReRegistrationNeeded -= x); + } +} + +namespace Windows.Media.SpeechRecognition +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpeechContinuousRecognitionSessionEvents Events(this global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession item) => new RxSpeechContinuousRecognitionSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpeechRecognizerEvents Events(this global::Windows.Media.SpeechRecognition.SpeechRecognizer item) => new RxSpeechRecognizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpeechContinuousRecognitionSessionEvents + { + private readonly global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpeechContinuousRecognitionSessionEvents(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args)> ResultGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResultGenerated += x, x => _data.ResultGenerated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpeechRecognizerEvents + { + private readonly global::Windows.Media.SpeechRecognition.SpeechRecognizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpeechRecognizerEvents(global::Windows.Media.SpeechRecognition.SpeechRecognizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args)> HypothesisGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HypothesisGenerated += x, x => _data.HypothesisGenerated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args)> RecognitionQualityDegrading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RecognitionQualityDegrading += x, x => _data.RecognitionQualityDegrading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace Windows.Media.Streaming.Adaptive +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAdaptiveMediaSourceEvents Events(this global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource item) => new RxAdaptiveMediaSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAdaptiveMediaSourceDiagnosticsEvents Events(this global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics item) => new RxAdaptiveMediaSourceDiagnosticsEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAdaptiveMediaSourceEvents + { + private readonly global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAdaptiveMediaSourceEvents(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args)> DownloadBitrateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadBitrateChanged += x, x => _data.DownloadBitrateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args)> DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args)> DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args)> DownloadRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadRequested += x, x => _data.DownloadRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args)> PlaybackBitrateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackBitrateChanged += x, x => _data.PlaybackBitrateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAdaptiveMediaSourceDiagnosticsEvents + { + private readonly global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAdaptiveMediaSourceDiagnosticsEvents(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args)> DiagnosticAvailable => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DiagnosticAvailable += x, x => _data.DiagnosticAvailable -= x); + } +} + +namespace Windows.Networking.BackgroundTransfer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDownloadOperationEvents Events(this global::Windows.Networking.BackgroundTransfer.DownloadOperation item) => new RxDownloadOperationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDownloadOperationEvents + { + private readonly global::Windows.Networking.BackgroundTransfer.DownloadOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDownloadOperationEvents(global::Windows.Networking.BackgroundTransfer.DownloadOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args)> RangesDownloaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RangesDownloaded += x, x => _data.RangesDownloaded -= x); + } +} + +namespace Windows.Networking.NetworkOperators +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxESimEvents Events(this global::Windows.Networking.NetworkOperators.ESim item) => new RxESimEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxESimProfileMetadataEvents Events(this global::Windows.Networking.NetworkOperators.ESimProfileMetadata item) => new RxESimProfileMetadataEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxESimWatcherEvents Events(this global::Windows.Networking.NetworkOperators.ESimWatcher item) => new RxESimWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMobileBroadbandAccountWatcherEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher item) => new RxMobileBroadbandAccountWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMobileBroadbandDeviceServiceDataSessionEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession item) => new RxMobileBroadbandDeviceServiceDataSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMobileBroadbandModemEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandModem item) => new RxMobileBroadbandModemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMobileBroadbandSarManagerEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager item) => new RxMobileBroadbandSarManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxESimEvents + { + private readonly global::Windows.Networking.NetworkOperators.ESim _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxESimEvents(global::Windows.Networking.NetworkOperators.ESim data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESim sender, object args)> ProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESim sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESim sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProfileChanged += x, x => _data.ProfileChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxESimProfileMetadataEvents + { + private readonly global::Windows.Networking.NetworkOperators.ESimProfileMetadata _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxESimProfileMetadataEvents(global::Windows.Networking.NetworkOperators.ESimProfileMetadata data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxESimWatcherEvents + { + private readonly global::Windows.Networking.NetworkOperators.ESimWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxESimWatcherEvents(global::Windows.Networking.NetworkOperators.ESimWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMobileBroadbandAccountWatcherEvents + { + private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMobileBroadbandAccountWatcherEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)> AccountAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccountAdded += x, x => _data.AccountAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)> AccountRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccountRemoved += x, x => _data.AccountRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args)> AccountUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccountUpdated += x, x => _data.AccountUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMobileBroadbandDeviceServiceDataSessionEvents + { + private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMobileBroadbandDeviceServiceDataSessionEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args)> DataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMobileBroadbandModemEvents + { + private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandModem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMobileBroadbandModemEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandModem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args)> IsInEmergencyCallModeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsInEmergencyCallModeChanged += x, x => _data.IsInEmergencyCallModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMobileBroadbandSarManagerEvents + { + private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMobileBroadbandSarManagerEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args)> TransmissionStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransmissionStateChanged += x, x => _data.TransmissionStateChanged -= x); + } +} + +namespace Windows.Networking.Proximity +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPeerWatcherEvents Events(this global::Windows.Networking.Proximity.PeerWatcher item) => new RxPeerWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProximityDeviceEvents Events(this global::Windows.Networking.Proximity.ProximityDevice item) => new RxProximityDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPeerWatcherEvents + { + private readonly global::Windows.Networking.Proximity.PeerWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPeerWatcherEvents(global::Windows.Networking.Proximity.PeerWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)>(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)>(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)>(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProximityDeviceEvents + { + private readonly global::Windows.Networking.Proximity.ProximityDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProximityDeviceEvents(global::Windows.Networking.Proximity.ProximityDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DeviceArrived => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); + return Handler; + }, x => _data.DeviceArrived += x, x => _data.DeviceArrived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DeviceDeparted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); + return Handler; + }, x => _data.DeviceDeparted += x, x => _data.DeviceDeparted -= x); + } +} + +namespace Windows.Networking.PushNotifications +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPushNotificationChannelEvents Events(this global::Windows.Networking.PushNotifications.PushNotificationChannel item) => new RxPushNotificationChannelEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPushNotificationChannelEvents + { + private readonly global::Windows.Networking.PushNotifications.PushNotificationChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPushNotificationChannelEvents(global::Windows.Networking.PushNotifications.PushNotificationChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args)> PushNotificationReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PushNotificationReceived += x, x => _data.PushNotificationReceived -= x); + } +} + +namespace Windows.Networking.ServiceDiscovery.Dnssd +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDnssdServiceWatcherEvents Events(this global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher item) => new RxDnssdServiceWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDnssdServiceWatcherEvents + { + private readonly global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDnssdServiceWatcherEvents(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args)>(eventHandler => + { + void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } +} + +namespace Windows.Networking.Sockets +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatagramSocketEvents Events(this global::Windows.Networking.Sockets.DatagramSocket item) => new RxDatagramSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIWebSocketEvents Events(this global::Windows.Networking.Sockets.IWebSocket item) => new RxIWebSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMessageWebSocketEvents Events(this global::Windows.Networking.Sockets.MessageWebSocket item) => new RxMessageWebSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxServerMessageWebSocketEvents Events(this global::Windows.Networking.Sockets.ServerMessageWebSocket item) => new RxServerMessageWebSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxServerStreamWebSocketEvents Events(this global::Windows.Networking.Sockets.ServerStreamWebSocket item) => new RxServerStreamWebSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStreamSocketListenerEvents Events(this global::Windows.Networking.Sockets.StreamSocketListener item) => new RxStreamSocketListenerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStreamWebSocketEvents Events(this global::Windows.Networking.Sockets.StreamWebSocket item) => new RxStreamWebSocketEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatagramSocketEvents + { + private readonly global::Windows.Networking.Sockets.DatagramSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatagramSocketEvents(global::Windows.Networking.Sockets.DatagramSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIWebSocketEvents + { + private readonly global::Windows.Networking.Sockets.IWebSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIWebSocketEvents(global::Windows.Networking.Sockets.IWebSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMessageWebSocketEvents + { + private readonly global::Windows.Networking.Sockets.MessageWebSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMessageWebSocketEvents(global::Windows.Networking.Sockets.MessageWebSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)> ServerCustomValidationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxServerMessageWebSocketEvents + { + private readonly global::Windows.Networking.Sockets.ServerMessageWebSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxServerMessageWebSocketEvents(global::Windows.Networking.Sockets.ServerMessageWebSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxServerStreamWebSocketEvents + { + private readonly global::Windows.Networking.Sockets.ServerStreamWebSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxServerStreamWebSocketEvents(global::Windows.Networking.Sockets.ServerStreamWebSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStreamSocketListenerEvents + { + private readonly global::Windows.Networking.Sockets.StreamSocketListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStreamSocketListenerEvents(global::Windows.Networking.Sockets.StreamSocketListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args)> ConnectionReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionReceived += x, x => _data.ConnectionReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStreamWebSocketEvents + { + private readonly global::Windows.Networking.Sockets.StreamWebSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStreamWebSocketEvents(global::Windows.Networking.Sockets.StreamWebSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)> ServerCustomValidationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + } +} + +namespace Windows.Networking.Vpn +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVpnChannelEvents Events(this global::Windows.Networking.Vpn.VpnChannel item) => new RxVpnChannelEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVpnChannelEvents + { + private readonly global::Windows.Networking.Vpn.VpnChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVpnChannelEvents(global::Windows.Networking.Vpn.VpnChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args)> ActivityChange => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActivityChange += x, x => _data.ActivityChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args)> ActivityStateChange => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActivityStateChange += x, x => _data.ActivityStateChange -= x); + } +} + +namespace Windows.Networking.XboxLive +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXboxLiveDeviceAddressEvents Events(this global::Windows.Networking.XboxLive.XboxLiveDeviceAddress item) => new RxXboxLiveDeviceAddressEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXboxLiveEndpointPairEvents Events(this global::Windows.Networking.XboxLive.XboxLiveEndpointPair item) => new RxXboxLiveEndpointPairEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXboxLiveEndpointPairTemplateEvents Events(this global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate item) => new RxXboxLiveEndpointPairTemplateEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXboxLiveDeviceAddressEvents + { + private readonly global::Windows.Networking.XboxLive.XboxLiveDeviceAddress _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXboxLiveDeviceAddressEvents(global::Windows.Networking.XboxLive.XboxLiveDeviceAddress data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.XboxLive.XboxLiveDeviceAddress sender, object args)> SnapshotChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.XboxLive.XboxLiveDeviceAddress sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.XboxLive.XboxLiveDeviceAddress sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SnapshotChanged += x, x => _data.SnapshotChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXboxLiveEndpointPairEvents + { + private readonly global::Windows.Networking.XboxLive.XboxLiveEndpointPair _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXboxLiveEndpointPairEvents(global::Windows.Networking.XboxLive.XboxLiveEndpointPair data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.XboxLive.XboxLiveEndpointPair sender, global::Windows.Networking.XboxLive.XboxLiveEndpointPairStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.XboxLive.XboxLiveEndpointPair sender, global::Windows.Networking.XboxLive.XboxLiveEndpointPairStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.XboxLive.XboxLiveEndpointPair sender, global::Windows.Networking.XboxLive.XboxLiveEndpointPairStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXboxLiveEndpointPairTemplateEvents + { + private readonly global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXboxLiveEndpointPairTemplateEvents(global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate sender, global::Windows.Networking.XboxLive.XboxLiveInboundEndpointPairCreatedEventArgs args)> InboundEndpointPairCreated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate sender, global::Windows.Networking.XboxLive.XboxLiveInboundEndpointPairCreatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate sender, global::Windows.Networking.XboxLive.XboxLiveInboundEndpointPairCreatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InboundEndpointPairCreated += x, x => _data.InboundEndpointPairCreated -= x); + } +} + +namespace Windows.Perception.Spatial +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialAnchorEvents Events(this global::Windows.Perception.Spatial.SpatialAnchor item) => new RxSpatialAnchorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialEntityWatcherEvents Events(this global::Windows.Perception.Spatial.SpatialEntityWatcher item) => new RxSpatialEntityWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialLocatorEvents Events(this global::Windows.Perception.Spatial.SpatialLocator item) => new RxSpatialLocatorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialAnchorEvents + { + private readonly global::Windows.Perception.Spatial.SpatialAnchor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialAnchorEvents(global::Windows.Perception.Spatial.SpatialAnchor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args)> RawCoordinateSystemAdjusted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RawCoordinateSystemAdjusted += x, x => _data.RawCoordinateSystemAdjusted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialEntityWatcherEvents + { + private readonly global::Windows.Perception.Spatial.SpatialEntityWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialEntityWatcherEvents(global::Windows.Perception.Spatial.SpatialEntityWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialLocatorEvents + { + private readonly global::Windows.Perception.Spatial.SpatialLocator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialLocatorEvents(global::Windows.Perception.Spatial.SpatialLocator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialLocator sender, object args)> LocatabilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialLocator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LocatabilityChanged += x, x => _data.LocatabilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args)> PositionalTrackingDeactivating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionalTrackingDeactivating += x, x => _data.PositionalTrackingDeactivating -= x); + } +} + +namespace Windows.Perception.Spatial.Surfaces +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialSurfaceObserverEvents Events(this global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver item) => new RxSpatialSurfaceObserverEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialSurfaceObserverEvents + { + private readonly global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialSurfaceObserverEvents(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args)> ObservedSurfacesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ObservedSurfacesChanged += x, x => _data.ObservedSurfacesChanged -= x); + } +} + +namespace Windows.Phone.Devices.Power +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBatteryEvents Events(this global::Windows.Phone.Devices.Power.Battery item) => new RxBatteryEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBatteryEvents + { + private readonly global::Windows.Phone.Devices.Power.Battery _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBatteryEvents(global::Windows.Phone.Devices.Power.Battery data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemainingChargePercentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.RemainingChargePercentChanged += x, x => _data.RemainingChargePercentChanged -= x); + } +} + +namespace Windows.Phone.Media.Devices +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioRoutingManagerEvents Events(this global::Windows.Phone.Media.Devices.AudioRoutingManager item) => new RxAudioRoutingManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioRoutingManagerEvents + { + private readonly global::Windows.Phone.Media.Devices.AudioRoutingManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioRoutingManagerEvents(global::Windows.Phone.Media.Devices.AudioRoutingManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args)> AudioEndpointChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioEndpointChanged += x, x => _data.AudioEndpointChanged -= x); + } +} + +namespace Windows.Security.Authentication.Web.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebAccountMonitorEvents Events(this global::Windows.Security.Authentication.Web.Core.WebAccountMonitor item) => new RxWebAccountMonitorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebAccountMonitorEvents + { + private readonly global::Windows.Security.Authentication.Web.Core.WebAccountMonitor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebAccountMonitorEvents(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)> AccountPictureUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccountPictureUpdated += x, x => _data.AccountPictureUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args)> DefaultSignInAccountChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args)>(eventHandler => + { + void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DefaultSignInAccountChanged += x, x => _data.DefaultSignInAccountChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace Windows.Security.Authorization.AppCapabilityAccess +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppCapabilityEvents Events(this global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability item) => new RxAppCapabilityEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppCapabilityEvents + { + private readonly global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppCapabilityEvents(global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability sender, global::Windows.Security.Authorization.AppCapabilityAccess.AppCapabilityAccessChangedEventArgs args)> AccessChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability sender, global::Windows.Security.Authorization.AppCapabilityAccess.AppCapabilityAccessChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability sender, global::Windows.Security.Authorization.AppCapabilityAccess.AppCapabilityAccessChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessChanged += x, x => _data.AccessChanged -= x); + } +} + +namespace Windows.Security.Credentials +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordCredentialPropertyStoreEvents Events(this global::Windows.Security.Credentials.PasswordCredentialPropertyStore item) => new RxPasswordCredentialPropertyStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordCredentialPropertyStoreEvents + { + private readonly global::Windows.Security.Credentials.PasswordCredentialPropertyStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordCredentialPropertyStoreEvents(global::Windows.Security.Credentials.PasswordCredentialPropertyStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } +} + +namespace Windows.Security.DataProtection +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserDataProtectionManagerEvents Events(this global::Windows.Security.DataProtection.UserDataProtectionManager item) => new RxUserDataProtectionManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserDataProtectionManagerEvents + { + private readonly global::Windows.Security.DataProtection.UserDataProtectionManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserDataProtectionManagerEvents(global::Windows.Security.DataProtection.UserDataProtectionManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.DataProtection.UserDataProtectionManager sender, global::Windows.Security.DataProtection.UserDataAvailabilityStateChangedEventArgs args)> DataAvailabilityStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.DataProtection.UserDataProtectionManager sender, global::Windows.Security.DataProtection.UserDataAvailabilityStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Security.DataProtection.UserDataProtectionManager sender, global::Windows.Security.DataProtection.UserDataAvailabilityStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataAvailabilityStateChanged += x, x => _data.DataAvailabilityStateChanged -= x); + } +} + +namespace Windows.Services.Maps.Guidance +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGuidanceNavigatorEvents Events(this global::Windows.Services.Maps.Guidance.GuidanceNavigator item) => new RxGuidanceNavigatorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGuidanceNavigatorEvents + { + private readonly global::Windows.Services.Maps.Guidance.GuidanceNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGuidanceNavigatorEvents(global::Windows.Services.Maps.Guidance.GuidanceNavigator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceAudioNotificationRequestedEventArgs args)> AudioNotificationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceAudioNotificationRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceAudioNotificationRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioNotificationRequested += x, x => _data.AudioNotificationRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)> DestinationReached => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DestinationReached += x, x => _data.DestinationReached -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs args)> GuidanceUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GuidanceUpdated += x, x => _data.GuidanceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceReroutedEventArgs args)> Rerouted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceReroutedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceReroutedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Rerouted += x, x => _data.Rerouted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)> RerouteFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RerouteFailed += x, x => _data.RerouteFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)> Rerouting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Rerouting += x, x => _data.Rerouting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)> UserLocationLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserLocationLost += x, x => _data.UserLocationLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)> UserLocationRestored => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserLocationRestored += x, x => _data.UserLocationRestored -= x); + } +} + +namespace Windows.Services.Maps.OfflineMaps +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxOfflineMapPackageEvents Events(this global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage item) => new RxOfflineMapPackageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxOfflineMapPackageEvents + { + private readonly global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxOfflineMapPackageEvents(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } +} + +namespace Windows.Services.Store +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStoreContextEvents Events(this global::Windows.Services.Store.StoreContext item) => new RxStoreContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorePackageLicenseEvents Events(this global::Windows.Services.Store.StorePackageLicense item) => new RxStorePackageLicenseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStoreQueueItemEvents Events(this global::Windows.Services.Store.StoreQueueItem item) => new RxStoreQueueItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStoreContextEvents + { + private readonly global::Windows.Services.Store.StoreContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStoreContextEvents(global::Windows.Services.Store.StoreContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Store.StoreContext sender, object args)> OfflineLicensesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Store.StoreContext sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Store.StoreContext sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OfflineLicensesChanged += x, x => _data.OfflineLicensesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorePackageLicenseEvents + { + private readonly global::Windows.Services.Store.StorePackageLicense _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorePackageLicenseEvents(global::Windows.Services.Store.StorePackageLicense data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Store.StorePackageLicense sender, object args)> LicenseLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Store.StorePackageLicense sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Store.StorePackageLicense sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LicenseLost += x, x => _data.LicenseLost -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStoreQueueItemEvents + { + private readonly global::Windows.Services.Store.StoreQueueItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStoreQueueItemEvents(global::Windows.Services.Store.StoreQueueItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Store.StoreQueueItem sender, global::Windows.Services.Store.StoreQueueItemCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Store.StoreQueueItem sender, global::Windows.Services.Store.StoreQueueItemCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.Store.StoreQueueItem sender, global::Windows.Services.Store.StoreQueueItemCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Store.StoreQueueItem sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Store.StoreQueueItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Store.StoreQueueItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } +} + +namespace Windows.Services.TargetedContent +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTargetedContentSubscriptionEvents Events(this global::Windows.Services.TargetedContent.TargetedContentSubscription item) => new RxTargetedContentSubscriptionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTargetedContentSubscriptionEvents + { + private readonly global::Windows.Services.TargetedContent.TargetedContentSubscription _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTargetedContentSubscriptionEvents(global::Windows.Services.TargetedContent.TargetedContentSubscription data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentAvailabilityChangedEventArgs args)> AvailabilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentAvailabilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentAvailabilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentChangedEventArgs args)> ContentChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentChanged += x, x => _data.ContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace Windows.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationDataEvents Events(this global::Windows.Storage.ApplicationData item) => new RxApplicationDataEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationDataCompositeValueEvents Events(this global::Windows.Storage.ApplicationDataCompositeValue item) => new RxApplicationDataCompositeValueEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationDataContainerSettingsEvents Events(this global::Windows.Storage.ApplicationDataContainerSettings item) => new RxApplicationDataContainerSettingsEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorageLibraryEvents Events(this global::Windows.Storage.StorageLibrary item) => new RxStorageLibraryEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationDataEvents + { + private readonly global::Windows.Storage.ApplicationData _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationDataEvents(global::Windows.Storage.ApplicationData data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.ApplicationData sender, object args)> DataChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.ApplicationData sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.ApplicationData sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationDataCompositeValueEvents + { + private readonly global::Windows.Storage.ApplicationDataCompositeValue _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationDataCompositeValueEvents(global::Windows.Storage.ApplicationDataCompositeValue data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationDataContainerSettingsEvents + { + private readonly global::Windows.Storage.ApplicationDataContainerSettings _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationDataContainerSettingsEvents(global::Windows.Storage.ApplicationDataContainerSettings data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorageLibraryEvents + { + private readonly global::Windows.Storage.StorageLibrary _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorageLibraryEvents(global::Windows.Storage.StorageLibrary data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.StorageLibrary sender, object args)> DefinitionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.StorageLibrary sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.StorageLibrary sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DefinitionChanged += x, x => _data.DefinitionChanged -= x); + } +} + +namespace Windows.Storage.AccessCache +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorageItemMostRecentlyUsedListEvents Events(this global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList item) => new RxStorageItemMostRecentlyUsedListEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorageItemMostRecentlyUsedListEvents + { + private readonly global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorageItemMostRecentlyUsedListEvents(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args)> ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + } +} + +namespace Windows.Storage.BulkAccess +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileInformationEvents Events(this global::Windows.Storage.BulkAccess.FileInformation item) => new RxFileInformationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderInformationEvents Events(this global::Windows.Storage.BulkAccess.FolderInformation item) => new RxFolderInformationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIStorageItemInformationEvents Events(this global::Windows.Storage.BulkAccess.IStorageItemInformation item) => new RxIStorageItemInformationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileInformationEvents + { + private readonly global::Windows.Storage.BulkAccess.FileInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileInformationEvents(global::Windows.Storage.BulkAccess.FileInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> PropertiesUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> ThumbnailUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderInformationEvents + { + private readonly global::Windows.Storage.BulkAccess.FolderInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderInformationEvents(global::Windows.Storage.BulkAccess.FolderInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> PropertiesUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> ThumbnailUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIStorageItemInformationEvents + { + private readonly global::Windows.Storage.BulkAccess.IStorageItemInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIStorageItemInformationEvents(global::Windows.Storage.BulkAccess.IStorageItemInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> PropertiesUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> ThumbnailUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + } +} + +namespace Windows.Storage.Pickers.Provider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileOpenPickerUIEvents Events(this global::Windows.Storage.Pickers.Provider.FileOpenPickerUI item) => new RxFileOpenPickerUIEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileSavePickerUIEvents Events(this global::Windows.Storage.Pickers.Provider.FileSavePickerUI item) => new RxFileSavePickerUIEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileOpenPickerUIEvents + { + private readonly global::Windows.Storage.Pickers.Provider.FileOpenPickerUI _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileOpenPickerUIEvents(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args)> FileRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FileRemoved += x, x => _data.FileRemoved -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileSavePickerUIEvents + { + private readonly global::Windows.Storage.Pickers.Provider.FileSavePickerUI _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileSavePickerUIEvents(global::Windows.Storage.Pickers.Provider.FileSavePickerUI data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args)> FileNameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FileNameChanged += x, x => _data.FileNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args)> TargetFileRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TargetFileRequested += x, x => _data.TargetFileRequested -= x); + } +} + +namespace Windows.Storage.Provider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCachedFileUpdaterUIEvents Events(this global::Windows.Storage.Provider.CachedFileUpdaterUI item) => new RxCachedFileUpdaterUIEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCachedFileUpdaterUIEvents + { + private readonly global::Windows.Storage.Provider.CachedFileUpdaterUI _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCachedFileUpdaterUIEvents(global::Windows.Storage.Provider.CachedFileUpdaterUI data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args)> FileUpdateRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FileUpdateRequested += x, x => _data.FileUpdateRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args)> UIRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UIRequested += x, x => _data.UIRequested -= x); + } +} + +namespace Windows.Storage.Search +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIStorageQueryResultBaseEvents Events(this global::Windows.Storage.Search.IStorageQueryResultBase item) => new RxIStorageQueryResultBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorageFileQueryResultEvents Events(this global::Windows.Storage.Search.StorageFileQueryResult item) => new RxStorageFileQueryResultEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorageFolderQueryResultEvents Events(this global::Windows.Storage.Search.StorageFolderQueryResult item) => new RxStorageFolderQueryResultEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorageItemQueryResultEvents Events(this global::Windows.Storage.Search.StorageItemQueryResult item) => new RxStorageItemQueryResultEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIStorageQueryResultBaseEvents + { + private readonly global::Windows.Storage.Search.IStorageQueryResultBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIStorageQueryResultBaseEvents(global::Windows.Storage.Search.IStorageQueryResultBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorageFileQueryResultEvents + { + private readonly global::Windows.Storage.Search.StorageFileQueryResult _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorageFileQueryResultEvents(global::Windows.Storage.Search.StorageFileQueryResult data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorageFolderQueryResultEvents + { + private readonly global::Windows.Storage.Search.StorageFolderQueryResult _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorageFolderQueryResultEvents(global::Windows.Storage.Search.StorageFolderQueryResult data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorageItemQueryResultEvents + { + private readonly global::Windows.Storage.Search.StorageItemQueryResult _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorageItemQueryResultEvents(global::Windows.Storage.Search.StorageItemQueryResult data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + } +} + +namespace Windows.System +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppDiagnosticInfoWatcherEvents Events(this global::Windows.System.AppDiagnosticInfoWatcher item) => new RxAppDiagnosticInfoWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppResourceGroupInfoWatcherEvents Events(this global::Windows.System.AppResourceGroupInfoWatcher item) => new RxAppResourceGroupInfoWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherQueueEvents Events(this global::Windows.System.DispatcherQueue item) => new RxDispatcherQueueEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherQueueTimerEvents Events(this global::Windows.System.DispatcherQueueTimer item) => new RxDispatcherQueueTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserWatcherEvents Events(this global::Windows.System.UserWatcher item) => new RxUserWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppDiagnosticInfoWatcherEvents + { + private readonly global::Windows.System.AppDiagnosticInfoWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppDiagnosticInfoWatcherEvents(global::Windows.System.AppDiagnosticInfoWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppResourceGroupInfoWatcherEvents + { + private readonly global::Windows.System.AppResourceGroupInfoWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppResourceGroupInfoWatcherEvents(global::Windows.System.AppResourceGroupInfoWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args)> ExecutionStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ExecutionStateChanged += x, x => _data.ExecutionStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherQueueEvents + { + private readonly global::Windows.System.DispatcherQueue _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherQueueEvents(global::Windows.System.DispatcherQueue data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.DispatcherQueue sender, object args)> ShutdownCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.DispatcherQueue sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.DispatcherQueue sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShutdownCompleted += x, x => _data.ShutdownCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args)> ShutdownStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShutdownStarting += x, x => _data.ShutdownStarting -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherQueueTimerEvents + { + private readonly global::Windows.System.DispatcherQueueTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherQueueTimerEvents(global::Windows.System.DispatcherQueueTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.DispatcherQueueTimer sender, object args)> Tick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.DispatcherQueueTimer sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.DispatcherQueueTimer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserWatcherEvents + { + private readonly global::Windows.System.UserWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserWatcherEvents(global::Windows.System.UserWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> AuthenticationStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AuthenticationStatusChanged += x, x => _data.AuthenticationStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args)> AuthenticationStatusChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AuthenticationStatusChanging += x, x => _data.AuthenticationStatusChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace Windows.System.Diagnostics.DevicePortal +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDevicePortalConnectionEvents Events(this global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection item) => new RxDevicePortalConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDevicePortalConnectionEvents + { + private readonly global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDevicePortalConnectionEvents(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args)> RequestReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + } +} + +namespace Windows.System.Preview +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTwoPanelHingedDevicePosturePreviewEvents Events(this global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview item) => new RxTwoPanelHingedDevicePosturePreviewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTwoPanelHingedDevicePosturePreviewEvents + { + private readonly global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTwoPanelHingedDevicePosturePreviewEvents(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args)> PostureChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PostureChanged += x, x => _data.PostureChanged -= x); + } +} + +namespace Windows.System.RemoteSystems +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSession item) => new RxRemoteSystemSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionControllerEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionController item) => new RxRemoteSystemSessionControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionInvitationListenerEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener item) => new RxRemoteSystemSessionInvitationListenerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionMessageChannelEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel item) => new RxRemoteSystemSessionMessageChannelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionParticipantWatcherEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher item) => new RxRemoteSystemSessionParticipantWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionWatcherEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher item) => new RxRemoteSystemSessionWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemWatcherEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemWatcher item) => new RxRemoteSystemWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionEvents(global::Windows.System.RemoteSystems.RemoteSystemSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args)> Disconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Disconnected += x, x => _data.Disconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionControllerEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionControllerEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args)> JoinRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.JoinRequested += x, x => _data.JoinRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionInvitationListenerEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionInvitationListenerEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args)> InvitationReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InvitationReceived += x, x => _data.InvitationReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionMessageChannelEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionMessageChannelEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args)> ValueSetReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValueSetReceived += x, x => _data.ValueSetReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionParticipantWatcherEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionParticipantWatcherEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionWatcherEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionWatcherEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemWatcherEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemWatcherEvents(global::Windows.System.RemoteSystems.RemoteSystemWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args)> RemoteSystemAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RemoteSystemAdded += x, x => _data.RemoteSystemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args)> RemoteSystemRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RemoteSystemRemoved += x, x => _data.RemoteSystemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args)> RemoteSystemUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RemoteSystemUpdated += x, x => _data.RemoteSystemUpdated -= x); + } +} + +namespace Windows.UI.Accessibility +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScreenReaderServiceEvents Events(this global::Windows.UI.Accessibility.ScreenReaderService item) => new RxScreenReaderServiceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScreenReaderServiceEvents + { + private readonly global::Windows.UI.Accessibility.ScreenReaderService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScreenReaderServiceEvents(global::Windows.UI.Accessibility.ScreenReaderService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args)> ScreenReaderPositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScreenReaderPositionChanged += x, x => _data.ScreenReaderPositionChanged -= x); + } +} + +namespace Windows.UI.ApplicationSettings +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAccountsSettingsPaneEvents Events(this global::Windows.UI.ApplicationSettings.AccountsSettingsPane item) => new RxAccountsSettingsPaneEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSettingsPaneEvents Events(this global::Windows.UI.ApplicationSettings.SettingsPane item) => new RxSettingsPaneEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAccountsSettingsPaneEvents + { + private readonly global::Windows.UI.ApplicationSettings.AccountsSettingsPane _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAccountsSettingsPaneEvents(global::Windows.UI.ApplicationSettings.AccountsSettingsPane data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args)> AccountCommandsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccountCommandsRequested += x, x => _data.AccountCommandsRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSettingsPaneEvents + { + private readonly global::Windows.UI.ApplicationSettings.SettingsPane _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSettingsPaneEvents(global::Windows.UI.ApplicationSettings.SettingsPane data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ApplicationSettings.SettingsPane sender, global::Windows.UI.ApplicationSettings.SettingsPaneCommandsRequestedEventArgs args)> CommandsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ApplicationSettings.SettingsPane sender, global::Windows.UI.ApplicationSettings.SettingsPaneCommandsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ApplicationSettings.SettingsPane sender, global::Windows.UI.ApplicationSettings.SettingsPaneCommandsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CommandsRequested += x, x => _data.CommandsRequested -= x); + } +} + +namespace Windows.UI.Composition +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompositionCapabilitiesEvents Events(this global::Windows.UI.Composition.CompositionCapabilities item) => new RxCompositionCapabilitiesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompositionCommitBatchEvents Events(this global::Windows.UI.Composition.CompositionCommitBatch item) => new RxCompositionCommitBatchEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompositionGraphicsDeviceEvents Events(this global::Windows.UI.Composition.CompositionGraphicsDevice item) => new RxCompositionGraphicsDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompositionScopedBatchEvents Events(this global::Windows.UI.Composition.CompositionScopedBatch item) => new RxCompositionScopedBatchEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompositionCapabilitiesEvents + { + private readonly global::Windows.UI.Composition.CompositionCapabilities _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompositionCapabilitiesEvents(global::Windows.UI.Composition.CompositionCapabilities data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Composition.CompositionCapabilities sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Composition.CompositionCapabilities sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Composition.CompositionCapabilities sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompositionCommitBatchEvents + { + private readonly global::Windows.UI.Composition.CompositionCommitBatch _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompositionCommitBatchEvents(global::Windows.UI.Composition.CompositionCommitBatch data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompositionGraphicsDeviceEvents + { + private readonly global::Windows.UI.Composition.CompositionGraphicsDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompositionGraphicsDeviceEvents(global::Windows.UI.Composition.CompositionGraphicsDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args)> RenderingDeviceReplaced => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RenderingDeviceReplaced += x, x => _data.RenderingDeviceReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompositionScopedBatchEvents + { + private readonly global::Windows.UI.Composition.CompositionScopedBatch _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompositionScopedBatchEvents(global::Windows.UI.Composition.CompositionScopedBatch data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } +} + +namespace Windows.UI.Composition.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompositorControllerEvents Events(this global::Windows.UI.Composition.Core.CompositorController item) => new RxCompositorControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompositorControllerEvents + { + private readonly global::Windows.UI.Composition.Core.CompositorController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompositorControllerEvents(global::Windows.UI.Composition.Core.CompositorController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Composition.Core.CompositorController sender, object args)> CommitNeeded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Composition.Core.CompositorController sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Composition.Core.CompositorController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CommitNeeded += x, x => _data.CommitNeeded -= x); + } +} + +namespace Windows.UI.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreAcceleratorKeysEvents Events(this global::Windows.UI.Core.CoreAcceleratorKeys item) => new RxCoreAcceleratorKeysEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreComponentInputSourceEvents Events(this global::Windows.UI.Core.CoreComponentInputSource item) => new RxCoreComponentInputSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreDispatcherEvents Events(this global::Windows.UI.Core.CoreDispatcher item) => new RxCoreDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreIndependentInputSourceEvents Events(this global::Windows.UI.Core.CoreIndependentInputSource item) => new RxCoreIndependentInputSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreWindowEvents Events(this global::Windows.UI.Core.CoreWindow item) => new RxCoreWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreWindowDialogEvents Events(this global::Windows.UI.Core.CoreWindowDialog item) => new RxCoreWindowDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreWindowFlyoutEvents Events(this global::Windows.UI.Core.CoreWindowFlyout item) => new RxCoreWindowFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICoreAcceleratorKeysEvents Events(this global::Windows.UI.Core.ICoreAcceleratorKeys item) => new RxICoreAcceleratorKeysEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICoreInputSourceBaseEvents Events(this global::Windows.UI.Core.ICoreInputSourceBase item) => new RxICoreInputSourceBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICorePointerInputSourceEvents Events(this global::Windows.UI.Core.ICorePointerInputSource item) => new RxICorePointerInputSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICorePointerRedirectorEvents Events(this global::Windows.UI.Core.ICorePointerRedirector item) => new RxICorePointerRedirectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICoreWindowEvents Events(this global::Windows.UI.Core.ICoreWindow item) => new RxICoreWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSystemNavigationManagerEvents Events(this global::Windows.UI.Core.SystemNavigationManager item) => new RxSystemNavigationManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreAcceleratorKeysEvents + { + private readonly global::Windows.UI.Core.CoreAcceleratorKeys _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreAcceleratorKeysEvents(global::Windows.UI.Core.CoreAcceleratorKeys data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)> AcceleratorKeyActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreComponentInputSourceEvents + { + private readonly global::Windows.UI.Core.CoreComponentInputSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreComponentInputSourceEvents(global::Windows.UI.Core.CoreComponentInputSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.CharacterReceivedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)> ClosestInteractiveBoundsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.CoreWindowEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.InputEnabledEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.KeyEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.KeyEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.CoreWindowEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchHitTesting => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.TouchHitTestingEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreDispatcherEvents + { + private readonly global::Windows.UI.Core.CoreDispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreDispatcherEvents(global::Windows.UI.Core.CoreDispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)> AcceleratorKeyActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreIndependentInputSourceEvents + { + private readonly global::Windows.UI.Core.CoreIndependentInputSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreIndependentInputSourceEvents(global::Windows.UI.Core.CoreIndependentInputSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.InputEnabledEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreWindowEvents + { + private readonly global::Windows.UI.Core.CoreWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreWindowEvents(global::Windows.UI.Core.CoreWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)> AutomationProviderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)> CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)> ClosestInteractiveBoundsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)> InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyDown => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyUp => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedAway => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedTo => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, object args)> ResizeCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResizeCompleted += x, x => _data.ResizeCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, object args)> ResizeStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResizeStarted += x, x => _data.ResizeStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)> SizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)> TouchHitTesting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)> VisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreWindowDialogEvents + { + private readonly global::Windows.UI.Core.CoreWindowDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreWindowDialogEvents(global::Windows.UI.Core.CoreWindowDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args)> Showing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Showing += x, x => _data.Showing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreWindowFlyoutEvents + { + private readonly global::Windows.UI.Core.CoreWindowFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreWindowFlyoutEvents(global::Windows.UI.Core.CoreWindowFlyout data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args)> Showing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Showing += x, x => _data.Showing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICoreAcceleratorKeysEvents + { + private readonly global::Windows.UI.Core.ICoreAcceleratorKeys _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICoreAcceleratorKeysEvents(global::Windows.UI.Core.ICoreAcceleratorKeys data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)> AcceleratorKeyActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICoreInputSourceBaseEvents + { + private readonly global::Windows.UI.Core.ICoreInputSourceBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICoreInputSourceBaseEvents(global::Windows.UI.Core.ICoreInputSourceBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.InputEnabledEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICorePointerInputSourceEvents + { + private readonly global::Windows.UI.Core.ICorePointerInputSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICorePointerInputSourceEvents(global::Windows.UI.Core.ICorePointerInputSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICorePointerRedirectorEvents + { + private readonly global::Windows.UI.Core.ICorePointerRedirector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICorePointerRedirectorEvents(global::Windows.UI.Core.ICorePointerRedirector data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedAway => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedTo => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICoreWindowEvents + { + private readonly global::Windows.UI.Core.ICoreWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICoreWindowEvents(global::Windows.UI.Core.ICoreWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)> AutomationProviderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)> CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)> InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyDown => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyUp => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)> SizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)> TouchHitTesting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)> VisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSystemNavigationManagerEvents + { + private readonly global::Windows.UI.Core.SystemNavigationManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSystemNavigationManagerEvents(global::Windows.UI.Core.SystemNavigationManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.BackRequestedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.BackRequestedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); + } +} + +namespace Windows.UI.Core.Preview +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSystemNavigationManagerPreviewEvents Events(this global::Windows.UI.Core.Preview.SystemNavigationManagerPreview item) => new RxSystemNavigationManagerPreviewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSystemNavigationManagerPreviewEvents + { + private readonly global::Windows.UI.Core.Preview.SystemNavigationManagerPreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSystemNavigationManagerPreviewEvents(global::Windows.UI.Core.Preview.SystemNavigationManagerPreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.Preview.SystemNavigationCloseRequestedPreviewEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.Preview.SystemNavigationCloseRequestedPreviewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + } +} + +namespace Windows.UI.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEdgeGestureEvents Events(this global::Windows.UI.Input.EdgeGesture item) => new RxEdgeGestureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGestureRecognizerEvents Events(this global::Windows.UI.Input.GestureRecognizer item) => new RxGestureRecognizerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputActivationListenerEvents Events(this global::Windows.UI.Input.InputActivationListener item) => new RxInputActivationListenerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxKeyboardDeliveryInterceptorEvents Events(this global::Windows.UI.Input.KeyboardDeliveryInterceptor item) => new RxKeyboardDeliveryInterceptorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadialControllerEvents Events(this global::Windows.UI.Input.RadialController item) => new RxRadialControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadialControllerMenuItemEvents Events(this global::Windows.UI.Input.RadialControllerMenuItem item) => new RxRadialControllerMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSystemButtonEventControllerEvents Events(this global::Windows.UI.Input.SystemButtonEventController item) => new RxSystemButtonEventControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEdgeGestureEvents + { + private readonly global::Windows.UI.Input.EdgeGesture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEdgeGestureEvents(global::Windows.UI.Input.EdgeGesture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)> Canceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Canceled += x, x => _data.Canceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)> Starting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Starting += x, x => _data.Starting -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGestureRecognizerEvents + { + private readonly global::Windows.UI.Input.GestureRecognizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGestureRecognizerEvents(global::Windows.UI.Input.GestureRecognizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args)> CrossSliding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CrossSliding += x, x => _data.CrossSliding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args)> Dragging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Dragging += x, x => _data.Dragging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args)> Holding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Holding += x, x => _data.Holding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args)> ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args)> ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args)> ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args)> ManipulationUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args)> RightTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args)> Tapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Tapped += x, x => _data.Tapped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputActivationListenerEvents + { + private readonly global::Windows.UI.Input.InputActivationListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputActivationListenerEvents(global::Windows.UI.Input.InputActivationListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.InputActivationListener sender, global::Windows.UI.Input.InputActivationListenerActivationChangedEventArgs args)> InputActivationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.InputActivationListener sender, global::Windows.UI.Input.InputActivationListenerActivationChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.InputActivationListener sender, global::Windows.UI.Input.InputActivationListenerActivationChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InputActivationChanged += x, x => _data.InputActivationChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxKeyboardDeliveryInterceptorEvents + { + private readonly global::Windows.UI.Input.KeyboardDeliveryInterceptor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxKeyboardDeliveryInterceptorEvents(global::Windows.UI.Input.KeyboardDeliveryInterceptor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)> KeyDown => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)> KeyUp => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadialControllerEvents + { + private readonly global::Windows.UI.Input.RadialController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadialControllerEvents(global::Windows.UI.Input.RadialController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args)> ButtonClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ButtonClicked += x, x => _data.ButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args)> ButtonHolding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ButtonHolding += x, x => _data.ButtonHolding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args)> ButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args)> ButtonReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ButtonReleased += x, x => _data.ButtonReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args)> ControlAcquired => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ControlAcquired += x, x => _data.ControlAcquired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, object args)> ControlLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args)> RotationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RotationChanged += x, x => _data.RotationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args)> ScreenContactContinued => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScreenContactContinued += x, x => _data.ScreenContactContinued -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, object args)> ScreenContactEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScreenContactEnded += x, x => _data.ScreenContactEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args)> ScreenContactStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScreenContactStarted += x, x => _data.ScreenContactStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadialControllerMenuItemEvents + { + private readonly global::Windows.UI.Input.RadialControllerMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadialControllerMenuItemEvents(global::Windows.UI.Input.RadialControllerMenuItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialControllerMenuItem sender, object args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialControllerMenuItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialControllerMenuItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Invoked += x, x => _data.Invoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSystemButtonEventControllerEvents + { + private readonly global::Windows.UI.Input.SystemButtonEventController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSystemButtonEventControllerEvents(global::Windows.UI.Input.SystemButtonEventController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args)> SystemFunctionButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemFunctionButtonPressed += x, x => _data.SystemFunctionButtonPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args)> SystemFunctionButtonReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemFunctionButtonReleased += x, x => _data.SystemFunctionButtonReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockChangedEventArgs args)> SystemFunctionLockChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemFunctionLockChanged += x, x => _data.SystemFunctionLockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockIndicatorChangedEventArgs args)> SystemFunctionLockIndicatorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockIndicatorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockIndicatorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemFunctionLockIndicatorChanged += x, x => _data.SystemFunctionLockIndicatorChanged -= x); + } +} + +namespace Windows.UI.Input.Inking +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkPresenterEvents Events(this global::Windows.UI.Input.Inking.InkPresenter item) => new RxInkPresenterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkStrokeInputEvents Events(this global::Windows.UI.Input.Inking.InkStrokeInput item) => new RxInkStrokeInputEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkUnprocessedInputEvents Events(this global::Windows.UI.Input.Inking.InkUnprocessedInput item) => new RxInkUnprocessedInputEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkPresenterEvents + { + private readonly global::Windows.UI.Input.Inking.InkPresenter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkPresenterEvents(global::Windows.UI.Input.Inking.InkPresenter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args)> StrokesCollected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokesCollected += x, x => _data.StrokesCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args)> StrokesErased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokesErased += x, x => _data.StrokesErased -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkStrokeInputEvents + { + private readonly global::Windows.UI.Input.Inking.InkStrokeInput _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkStrokeInputEvents(global::Windows.UI.Input.Inking.InkStrokeInput data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokeCanceled += x, x => _data.StrokeCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeContinued => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokeContinued += x, x => _data.StrokeContinued -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokeEnded += x, x => _data.StrokeEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokeStarted += x, x => _data.StrokeStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkUnprocessedInputEvents + { + private readonly global::Windows.UI.Input.Inking.InkUnprocessedInput _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkUnprocessedInputEvents(global::Windows.UI.Input.Inking.InkUnprocessedInput data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerHovered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerHovered += x, x => _data.PointerHovered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + } +} + +namespace Windows.UI.Input.Inking.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreInkIndependentInputSourceEvents Events(this global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource item) => new RxCoreInkIndependentInputSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreWetStrokeUpdateSourceEvents Events(this global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource item) => new RxCoreWetStrokeUpdateSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreInkIndependentInputSourceEvents + { + private readonly global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreInkIndependentInputSourceEvents(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntering => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerEntering += x, x => _data.PointerEntering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExiting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerExiting += x, x => _data.PointerExiting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerHovering => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerHovering += x, x => _data.PointerHovering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoving => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerMoving += x, x => _data.PointerMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerPressing += x, x => _data.PointerPressing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleasing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerReleasing += x, x => _data.PointerReleasing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreWetStrokeUpdateSourceEvents + { + private readonly global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreWetStrokeUpdateSourceEvents(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WetStrokeCanceled += x, x => _data.WetStrokeCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WetStrokeCompleted += x, x => _data.WetStrokeCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeContinuing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WetStrokeContinuing += x, x => _data.WetStrokeContinuing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WetStrokeStarting += x, x => _data.WetStrokeStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeStopping => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WetStrokeStopping += x, x => _data.WetStrokeStopping -= x); + } +} + +namespace Windows.UI.Input.Spatial +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialGestureRecognizerEvents Events(this global::Windows.UI.Input.Spatial.SpatialGestureRecognizer item) => new RxSpatialGestureRecognizerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialInteractionManagerEvents Events(this global::Windows.UI.Input.Spatial.SpatialInteractionManager item) => new RxSpatialInteractionManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialGestureRecognizerEvents + { + private readonly global::Windows.UI.Input.Spatial.SpatialGestureRecognizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialGestureRecognizerEvents(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args)> HoldCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HoldCanceled += x, x => _data.HoldCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args)> HoldCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HoldCompleted += x, x => _data.HoldCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args)> HoldStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HoldStarted += x, x => _data.HoldStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args)> ManipulationCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationCanceled += x, x => _data.ManipulationCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args)> ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args)> ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args)> ManipulationUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args)> NavigationCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCanceled += x, x => _data.NavigationCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args)> NavigationStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationStarted += x, x => _data.NavigationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args)> NavigationUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationUpdated += x, x => _data.NavigationUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args)> RecognitionEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RecognitionEnded += x, x => _data.RecognitionEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args)> RecognitionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RecognitionStarted += x, x => _data.RecognitionStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args)> Tapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Tapped += x, x => _data.Tapped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialInteractionManagerEvents + { + private readonly global::Windows.UI.Input.Spatial.SpatialInteractionManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialInteractionManagerEvents(global::Windows.UI.Input.Spatial.SpatialInteractionManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args)> InteractionDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InteractionDetected += x, x => _data.InteractionDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceDetected += x, x => _data.SourceDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceLost += x, x => _data.SourceLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourcePressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourcePressed += x, x => _data.SourcePressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceReleased += x, x => _data.SourceReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + } +} + +namespace Windows.UI.Notifications +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToastNotificationEvents Events(this global::Windows.UI.Notifications.ToastNotification item) => new RxToastNotificationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToastNotifierEvents Events(this global::Windows.UI.Notifications.ToastNotifier item) => new RxToastNotifierEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToastNotificationEvents + { + private readonly global::Windows.UI.Notifications.ToastNotification _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToastNotificationEvents(global::Windows.UI.Notifications.ToastNotification data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotification sender, object args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotification sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Notifications.ToastNotification sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args)> Dismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args)> Failed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToastNotifierEvents + { + private readonly global::Windows.UI.Notifications.ToastNotifier _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToastNotifierEvents(global::Windows.UI.Notifications.ToastNotifier data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args)> ScheduledToastNotificationShowing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScheduledToastNotificationShowing += x, x => _data.ScheduledToastNotificationShowing -= x); + } +} + +namespace Windows.UI.Notifications.Management +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserNotificationListenerEvents Events(this global::Windows.UI.Notifications.Management.UserNotificationListener item) => new RxUserNotificationListenerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserNotificationListenerEvents + { + private readonly global::Windows.UI.Notifications.Management.UserNotificationListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserNotificationListenerEvents(global::Windows.UI.Notifications.Management.UserNotificationListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args)> NotificationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NotificationChanged += x, x => _data.NotificationChanged -= x); + } +} + +namespace Windows.UI.StartScreen +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSecondaryTileEvents Events(this global::Windows.UI.StartScreen.SecondaryTile item) => new RxSecondaryTileEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSecondaryTileEvents + { + private readonly global::Windows.UI.StartScreen.SecondaryTile _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSecondaryTileEvents(global::Windows.UI.StartScreen.SecondaryTile data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args)> VisualElementsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisualElementsRequested += x, x => _data.VisualElementsRequested -= x); + } +} + +namespace Windows.UI.Text.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreTextEditContextEvents Events(this global::Windows.UI.Text.Core.CoreTextEditContext item) => new RxCoreTextEditContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreTextServicesManagerEvents Events(this global::Windows.UI.Text.Core.CoreTextServicesManager item) => new RxCoreTextServicesManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreTextEditContextEvents + { + private readonly global::Windows.UI.Text.Core.CoreTextEditContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreTextEditContextEvents(global::Windows.UI.Text.Core.CoreTextEditContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args)> CompositionCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CompositionCompleted += x, x => _data.CompositionCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args)> CompositionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CompositionStarted += x, x => _data.CompositionStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)> FocusRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FocusRemoved += x, x => _data.FocusRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args)> FormatUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FormatUpdating += x, x => _data.FormatUpdating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args)> LayoutRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LayoutRequested += x, x => _data.LayoutRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)> NotifyFocusLeaveCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NotifyFocusLeaveCompleted += x, x => _data.NotifyFocusLeaveCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args)> SelectionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionRequested += x, x => _data.SelectionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args)> SelectionUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionUpdating += x, x => _data.SelectionUpdating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args)> TextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextRequested += x, x => _data.TextRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args)> TextUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextUpdating += x, x => _data.TextUpdating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreTextServicesManagerEvents + { + private readonly global::Windows.UI.Text.Core.CoreTextServicesManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreTextServicesManagerEvents(global::Windows.UI.Text.Core.CoreTextServicesManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args)> InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + } +} + +namespace Windows.UI.ViewManagement +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAccessibilitySettingsEvents Events(this global::Windows.UI.ViewManagement.AccessibilitySettings item) => new RxAccessibilitySettingsEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationViewEvents Events(this global::Windows.UI.ViewManagement.ApplicationView item) => new RxApplicationViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputPaneEvents Events(this global::Windows.UI.ViewManagement.InputPane item) => new RxInputPaneEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::Windows.UI.ViewManagement.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUISettingsEvents Events(this global::Windows.UI.ViewManagement.UISettings item) => new RxUISettingsEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAccessibilitySettingsEvents + { + private readonly global::Windows.UI.ViewManagement.AccessibilitySettings _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAccessibilitySettingsEvents(global::Windows.UI.ViewManagement.AccessibilitySettings data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args)> HighContrastChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HighContrastChanged += x, x => _data.HighContrastChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationViewEvents + { + private readonly global::Windows.UI.ViewManagement.ApplicationView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationViewEvents(global::Windows.UI.ViewManagement.ApplicationView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args)> Consolidated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Consolidated += x, x => _data.Consolidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.ApplicationView sender, object args)> VisibleBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.ApplicationView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisibleBoundsChanged += x, x => _data.VisibleBoundsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputPaneEvents + { + private readonly global::Windows.UI.ViewManagement.InputPane _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputPaneEvents(global::Windows.UI.ViewManagement.InputPane data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)> Hiding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Hiding += x, x => _data.Hiding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)> Showing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Showing += x, x => _data.Showing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents + { + private readonly global::Windows.UI.ViewManagement.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::Windows.UI.ViewManagement.StatusBar data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.StatusBar sender, object args)> Hiding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.StatusBar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Hiding += x, x => _data.Hiding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.StatusBar sender, object args)> Showing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.StatusBar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Showing += x, x => _data.Showing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUISettingsEvents + { + private readonly global::Windows.UI.ViewManagement.UISettings _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUISettingsEvents(global::Windows.UI.ViewManagement.UISettings data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, object args)> AdvancedEffectsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AdvancedEffectsEnabledChanged += x, x => _data.AdvancedEffectsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAnimationsEnabledChangedEventArgs args)> AnimationsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAnimationsEnabledChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAnimationsEnabledChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AnimationsEnabledChanged += x, x => _data.AnimationsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAutoHideScrollBarsChangedEventArgs args)> AutoHideScrollBarsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAutoHideScrollBarsChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAutoHideScrollBarsChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutoHideScrollBarsChanged += x, x => _data.AutoHideScrollBarsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, object args)> ColorValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ColorValuesChanged += x, x => _data.ColorValuesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsMessageDurationChangedEventArgs args)> MessageDurationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsMessageDurationChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsMessageDurationChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageDurationChanged += x, x => _data.MessageDurationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, object args)> TextScaleFactorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextScaleFactorChanged += x, x => _data.TextScaleFactorChanged -= x); + } +} + +namespace Windows.UI.ViewManagement.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreInputViewEvents Events(this global::Windows.UI.ViewManagement.Core.CoreInputView item) => new RxCoreInputViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreInputViewEvents + { + private readonly global::Windows.UI.ViewManagement.Core.CoreInputView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreInputViewEvents(global::Windows.UI.ViewManagement.Core.CoreInputView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args)> OcclusionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OcclusionsChanged += x, x => _data.OcclusionsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewHidingEventArgs args)> PrimaryViewHiding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewHidingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewHidingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrimaryViewHiding += x, x => _data.PrimaryViewHiding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewShowingEventArgs args)> PrimaryViewShowing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewShowingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewShowingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrimaryViewShowing += x, x => _data.PrimaryViewShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args)> XYFocusTransferredToPrimaryView => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.XYFocusTransferredToPrimaryView += x, x => _data.XYFocusTransferredToPrimaryView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args)> XYFocusTransferringFromPrimaryView => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.XYFocusTransferringFromPrimaryView += x, x => _data.XYFocusTransferringFromPrimaryView -= x); + } +} + +namespace Windows.UI.WebUI +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebUIBackgroundTaskInstanceRuntimeClassEvents Events(this global::Windows.UI.WebUI.WebUIBackgroundTaskInstanceRuntimeClass item) => new RxWebUIBackgroundTaskInstanceRuntimeClassEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebUIViewEvents Events(this global::Windows.UI.WebUI.WebUIView item) => new RxWebUIViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebUIBackgroundTaskInstanceRuntimeClassEvents + { + private readonly global::Windows.UI.WebUI.WebUIBackgroundTaskInstanceRuntimeClass _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebUIBackgroundTaskInstanceRuntimeClassEvents(global::Windows.UI.WebUI.WebUIBackgroundTaskInstanceRuntimeClass data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason)> Canceled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); + return Handler; + }, x => _data.Canceled += x, x => _data.Canceled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebUIViewEvents + { + private readonly global::Windows.UI.WebUI.WebUIView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebUIViewEvents(global::Windows.UI.WebUI.WebUIView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WebUI.WebUIView sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WebUI.WebUIView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.WebUI.WebUIView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)> ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + } +} + +namespace Windows.UI.WebUI.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebUICommandBarEvents Events(this global::Windows.UI.WebUI.Core.WebUICommandBar item) => new RxWebUICommandBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebUICommandBarConfirmationButtonEvents Events(this global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton item) => new RxWebUICommandBarConfirmationButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebUICommandBarIconButtonEvents Events(this global::Windows.UI.WebUI.Core.WebUICommandBarIconButton item) => new RxWebUICommandBarIconButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebUICommandBarEvents + { + private readonly global::Windows.UI.WebUI.Core.WebUICommandBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebUICommandBarEvents(global::Windows.UI.WebUI.Core.WebUICommandBar data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler() => eventHandler(global::System.Reactive.Unit.Default); + return Handler; + }, x => _data.MenuClosed += x, x => _data.MenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler() => eventHandler(global::System.Reactive.Unit.Default); + return Handler; + }, x => _data.MenuOpened += x, x => _data.MenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.UI.WebUI.Core.WebUICommandBarSizeChangedEventArgs eventArgs) => eventHandler(eventArgs); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebUICommandBarConfirmationButtonEvents + { + private readonly global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebUICommandBarConfirmationButtonEvents(global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args)> ItemInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebUICommandBarIconButtonEvents + { + private readonly global::Windows.UI.WebUI.Core.WebUICommandBarIconButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebUICommandBarIconButtonEvents(global::Windows.UI.WebUI.Core.WebUICommandBarIconButton data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WebUI.Core.WebUICommandBarIconButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args)> ItemInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WebUI.Core.WebUICommandBarIconButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WebUI.Core.WebUICommandBarIconButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + } +} + +namespace Windows.UI.WindowManagement +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppWindowEvents Events(this global::Windows.UI.WindowManagement.AppWindow item) => new RxAppWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDisplayRegionEvents Events(this global::Windows.UI.WindowManagement.DisplayRegion item) => new RxDisplayRegionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowingEnvironmentEvents Events(this global::Windows.UI.WindowManagement.WindowingEnvironment item) => new RxWindowingEnvironmentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppWindowEvents + { + private readonly global::Windows.UI.WindowManagement.AppWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppWindowEvents(global::Windows.UI.WindowManagement.AppWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowChangedEventArgs args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowCloseRequestedEventArgs args)> CloseRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowCloseRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowCloseRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDisplayRegionEvents + { + private readonly global::Windows.UI.WindowManagement.DisplayRegion _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDisplayRegionEvents(global::Windows.UI.WindowManagement.DisplayRegion data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WindowManagement.DisplayRegion sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WindowManagement.DisplayRegion sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.WindowManagement.DisplayRegion sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowingEnvironmentEvents + { + private readonly global::Windows.UI.WindowManagement.WindowingEnvironment _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowingEnvironmentEvents(global::Windows.UI.WindowManagement.WindowingEnvironment data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WindowManagement.WindowingEnvironment sender, global::Windows.UI.WindowManagement.WindowingEnvironmentChangedEventArgs args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WindowManagement.WindowingEnvironment sender, global::Windows.UI.WindowManagement.WindowingEnvironmentChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WindowManagement.WindowingEnvironment sender, global::Windows.UI.WindowManagement.WindowingEnvironmentChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace Windows.UI.Xaml +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::Windows.UI.Xaml.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDebugSettingsEvents Events(this global::Windows.UI.Xaml.DebugSettings item) => new RxDebugSettingsEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDependencyObjectCollectionEvents Events(this global::Windows.UI.Xaml.DependencyObjectCollection item) => new RxDependencyObjectCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::Windows.UI.Xaml.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::Windows.UI.Xaml.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::Windows.UI.Xaml.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::Windows.UI.Xaml.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::Windows.UI.Xaml.Window item) => new RxWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlRootEvents Events(this global::Windows.UI.Xaml.XamlRoot item) => new RxXamlRootEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::Windows.UI.Xaml.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::Windows.UI.Xaml.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnteredBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnteredBackground += x, x => _data.EnteredBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeavingBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeavingBackground += x, x => _data.LeavingBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resuming => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Resuming += x, x => _data.Resuming -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Suspending => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Suspending += x, x => _data.Suspending -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.UnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDebugSettingsEvents + { + private readonly global::Windows.UI.Xaml.DebugSettings _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDebugSettingsEvents(global::Windows.UI.Xaml.DebugSettings data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.BindingFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingFailed += x, x => _data.BindingFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDependencyObjectCollectionEvents + { + private readonly global::Windows.UI.Xaml.DependencyObjectCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDependencyObjectCollectionEvents(global::Windows.UI.Xaml.DependencyObjectCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event)> VectorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::Windows.UI.Xaml.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::Windows.UI.Xaml.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::Windows.UI.Xaml.RxUIElementEvents + { + private readonly global::Windows.UI.Xaml.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::Windows.UI.Xaml.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.FrameworkElement sender, object args)> ActualThemeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.FrameworkElement sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.FrameworkElement sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActualThemeChanged += x, x => _data.ActualThemeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args)> EffectiveViewportChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EffectiveViewportChanged += x, x => _data.EffectiveViewportChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.FrameworkElement sender, object args)> Loading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.FrameworkElement sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.FrameworkElement sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Loading += x, x => _data.Loading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::Windows.UI.Xaml.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::Windows.UI.Xaml.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)> AccessKeyDisplayDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)> AccessKeyDisplayRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)> AccessKeyInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args)> BringIntoViewRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BringIntoViewRequested += x, x => _data.BringIntoViewRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args)> CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args)> ContextCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContextCanceled += x, x => _data.ContextCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args)> ContextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContextRequested += x, x => _data.ContextRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleTapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args)> DragStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DragStarting += x, x => _data.DragStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args)> DropCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DropCompleted += x, x => _data.DropCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args)> GettingFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GettingFocus += x, x => _data.GettingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Holding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.HoldingRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Holding += x, x => _data.Holding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args)> LosingFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args)> NoFocusCandidateFound => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NoFocusCandidateFound += x, x => _data.NoFocusCandidateFound -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCanceled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerCanceled += x, x => _data.PointerCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args)> ProcessKeyboardAccelerators => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProcessKeyboardAccelerators += x, x => _data.ProcessKeyboardAccelerators -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightTapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.RightTappedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.TappedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tapped += x, x => _data.Tapped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::Windows.UI.Xaml.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::Windows.UI.Xaml.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents + { + private readonly global::Windows.UI.Xaml.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::Windows.UI.Xaml.Window data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.WindowActivatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.WindowSizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.VisibilityChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlRootEvents + { + private readonly global::Windows.UI.Xaml.XamlRoot _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlRootEvents(global::Windows.UI.Xaml.XamlRoot data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.XamlRoot sender, global::Windows.UI.Xaml.XamlRootChangedEventArgs args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.XamlRoot sender, global::Windows.UI.Xaml.XamlRootChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.XamlRoot sender, global::Windows.UI.Xaml.XamlRootChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace Windows.UI.Xaml.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBarEvents Events(this global::Windows.UI.Xaml.Controls.AppBar item) => new RxAppBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoSuggestBoxEvents Events(this global::Windows.UI.Xaml.Controls.AutoSuggestBox item) => new RxAutoSuggestBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDatePickerEvents Events(this global::Windows.UI.Xaml.Controls.CalendarDatePicker item) => new RxCalendarDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarViewEvents Events(this global::Windows.UI.Xaml.Controls.CalendarView item) => new RxCalendarViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxColorPickerEvents Events(this global::Windows.UI.Xaml.Controls.ColorPicker item) => new RxColorPickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::Windows.UI.Xaml.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBarEvents Events(this global::Windows.UI.Xaml.Controls.CommandBar item) => new RxCommandBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentDialogEvents Events(this global::Windows.UI.Xaml.Controls.ContentDialog item) => new RxContentDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::Windows.UI.Xaml.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::Windows.UI.Xaml.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.DatePickerFlyout item) => new RxDatePickerFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::Windows.UI.Xaml.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHandwritingViewEvents Events(this global::Windows.UI.Xaml.Controls.HandwritingView item) => new RxHandwritingViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHubEvents Events(this global::Windows.UI.Xaml.Controls.Hub item) => new RxHubEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::Windows.UI.Xaml.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkToolbarEvents Events(this global::Windows.UI.Xaml.Controls.InkToolbar item) => new RxInkToolbarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkToolbarFlyoutItemEvents Events(this global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem item) => new RxInkToolbarFlyoutItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemCollectionEvents Events(this global::Windows.UI.Xaml.Controls.ItemCollection item) => new RxItemCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::Windows.UI.Xaml.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemsPresenterEvents Events(this global::Windows.UI.Xaml.Controls.ItemsPresenter item) => new RxItemsPresenterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListPickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.ListPickerFlyout item) => new RxListPickerFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewBaseEvents Events(this global::Windows.UI.Xaml.Controls.ListViewBase item) => new RxListViewBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::Windows.UI.Xaml.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaTransportControlsEvents Events(this global::Windows.UI.Xaml.Controls.MediaTransportControls item) => new RxMediaTransportControlsEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuFlyoutItemEvents Events(this global::Windows.UI.Xaml.Controls.MenuFlyoutItem item) => new RxMenuFlyoutItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationViewEvents Events(this global::Windows.UI.Xaml.Controls.NavigationView item) => new RxNavigationViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::Windows.UI.Xaml.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.PickerFlyout item) => new RxPickerFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPivotEvents Events(this global::Windows.UI.Xaml.Controls.Pivot item) => new RxPivotEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRatingControlEvents Events(this global::Windows.UI.Xaml.Controls.RatingControl item) => new RxRatingControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRefreshContainerEvents Events(this global::Windows.UI.Xaml.Controls.RefreshContainer item) => new RxRefreshContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRefreshVisualizerEvents Events(this global::Windows.UI.Xaml.Controls.RefreshVisualizer item) => new RxRefreshVisualizerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichEditBoxEvents Events(this global::Windows.UI.Xaml.Controls.RichEditBox item) => new RxRichEditBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBlockEvents Events(this global::Windows.UI.Xaml.Controls.RichTextBlock item) => new RxRichTextBlockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBlockOverflowEvents Events(this global::Windows.UI.Xaml.Controls.RichTextBlockOverflow item) => new RxRichTextBlockOverflowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::Windows.UI.Xaml.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSearchBoxEvents Events(this global::Windows.UI.Xaml.Controls.SearchBox item) => new RxSearchBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSemanticZoomEvents Events(this global::Windows.UI.Xaml.Controls.SemanticZoom item) => new RxSemanticZoomEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSettingsFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.SettingsFlyout item) => new RxSettingsFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitButtonEvents Events(this global::Windows.UI.Xaml.Controls.SplitButton item) => new RxSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitViewEvents Events(this global::Windows.UI.Xaml.Controls.SplitView item) => new RxSplitViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStackPanelEvents Events(this global::Windows.UI.Xaml.Controls.StackPanel item) => new RxStackPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSwapChainPanelEvents Events(this global::Windows.UI.Xaml.Controls.SwapChainPanel item) => new RxSwapChainPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSwipeItemEvents Events(this global::Windows.UI.Xaml.Controls.SwipeItem item) => new RxSwipeItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBlockEvents Events(this global::Windows.UI.Xaml.Controls.TextBlock item) => new RxTextBlockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::Windows.UI.Xaml.Controls.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimePickerEvents Events(this global::Windows.UI.Xaml.Controls.TimePicker item) => new RxTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimePickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.TimePickerFlyout item) => new RxTimePickerFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleSplitButtonEvents Events(this global::Windows.UI.Xaml.Controls.ToggleSplitButton item) => new RxToggleSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleSwitchEvents Events(this global::Windows.UI.Xaml.Controls.ToggleSwitch item) => new RxToggleSwitchEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::Windows.UI.Xaml.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::Windows.UI.Xaml.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTwoPaneViewEvents Events(this global::Windows.UI.Xaml.Controls.TwoPaneView item) => new RxTwoPaneViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVirtualizingStackPanelEvents Events(this global::Windows.UI.Xaml.Controls.VirtualizingStackPanel item) => new RxVirtualizingStackPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebViewEvents Events(this global::Windows.UI.Xaml.Controls.WebView item) => new RxWebViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBarEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.AppBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBarEvents(global::Windows.UI.Xaml.Controls.AppBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoSuggestBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.AutoSuggestBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoSuggestBoxEvents(global::Windows.UI.Xaml.Controls.AutoSuggestBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args)> QuerySubmitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args)> SuggestionChosen => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SuggestionChosen += x, x => _data.SuggestionChosen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args)> TextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDatePickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.CalendarDatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDatePickerEvents(global::Windows.UI.Xaml.Controls.CalendarDatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs e)> CalendarViewDayItemChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args)> DateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.CalendarView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarViewEvents(global::Windows.UI.Xaml.Controls.CalendarView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args)> CalendarViewDayItemChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args)> SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxColorPickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.ColorPicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxColorPickerEvents(global::Windows.UI.Xaml.Controls.ColorPicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)> ColorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::Windows.UI.Xaml.Controls.Primitives.RxSelectorEvents + { + private readonly global::Windows.UI.Xaml.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::Windows.UI.Xaml.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args)> TextSubmitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextSubmitted += x, x => _data.TextSubmitted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBarEvents : global::Windows.UI.Xaml.Controls.RxAppBarEvents + { + private readonly global::Windows.UI.Xaml.Controls.CommandBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBarEvents(global::Windows.UI.Xaml.Controls.CommandBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args)> DynamicOverflowItemsChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DynamicOverflowItemsChanging += x, x => _data.DynamicOverflowItemsChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentDialogEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.ContentDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentDialogEvents(global::Windows.UI.Xaml.Controls.ContentDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)> CloseButtonClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CloseButtonClick += x, x => _data.CloseButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)> PrimaryButtonClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrimaryButtonClick += x, x => _data.PrimaryButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)> SecondaryButtonClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SecondaryButtonClick += x, x => _data.SecondaryButtonClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::Windows.UI.Xaml.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args)> FocusDisengaged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FocusDisengaged += x, x => _data.FocusDisengaged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args)> FocusEngaged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FocusEngaged += x, x => _data.FocusEngaged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::Windows.UI.Xaml.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args)> SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.DatePickerFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerFlyoutEvents(global::Windows.UI.Xaml.Controls.DatePickerFlyout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args)> DatePicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DatePicked += x, x => _data.DatePicked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::Windows.UI.Xaml.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHandwritingViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.HandwritingView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHandwritingViewEvents(global::Windows.UI.Xaml.Controls.HandwritingView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHubEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Hub _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHubEvents(global::Windows.UI.Xaml.Controls.Hub data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SectionHeaderClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.HubSectionHeaderClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SectionHeaderClick += x, x => _data.SectionHeaderClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SectionsInViewChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SectionsInViewChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SectionsInViewChanged += x, x => _data.SectionsInViewChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::Windows.UI.Xaml.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkToolbarEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.InkToolbar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkToolbarEvents(global::Windows.UI.Xaml.Controls.InkToolbar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> ActiveToolChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActiveToolChanged += x, x => _data.ActiveToolChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> EraseAllClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EraseAllClicked += x, x => _data.EraseAllClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> InkDrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InkDrawingAttributesChanged += x, x => _data.InkDrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> IsRulerButtonCheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsRulerButtonCheckedChanged += x, x => _data.IsRulerButtonCheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args)> IsStencilButtonCheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsStencilButtonCheckedChanged += x, x => _data.IsStencilButtonCheckedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkToolbarFlyoutItemEvents : global::Windows.UI.Xaml.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkToolbarFlyoutItemEvents(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)> Checked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)> Unchecked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemCollectionEvents + { + private readonly global::Windows.UI.Xaml.Controls.ItemCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemCollectionEvents(global::Windows.UI.Xaml.Controls.ItemCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event)> VectorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::Windows.UI.Xaml.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::Windows.UI.Xaml.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemsPresenterEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.ItemsPresenter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemsPresenterEvents(global::Windows.UI.Xaml.Controls.ItemsPresenter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListPickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.ListPickerFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListPickerFlyoutEvents(global::Windows.UI.Xaml.Controls.ListPickerFlyout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args)> ItemsPicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemsPicked += x, x => _data.ItemsPicked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewBaseEvents : global::Windows.UI.Xaml.Controls.Primitives.RxSelectorEvents + { + private readonly global::Windows.UI.Xaml.Controls.ListViewBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewBaseEvents(global::Windows.UI.Xaml.Controls.ListViewBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args)> ChoosingGroupHeaderContainer => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ChoosingGroupHeaderContainer += x, x => _data.ChoosingGroupHeaderContainer -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args)> ChoosingItemContainer => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ChoosingItemContainer += x, x => _data.ChoosingItemContainer -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args)> ContainerContentChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContainerContentChanging += x, x => _data.ContainerContentChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args)> DragItemsCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragItemsStarting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.DragItemsStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ItemClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::Windows.UI.Xaml.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarkerReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Media.TimelineMarkerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarkerReached += x, x => _data.MarkerReached -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args)> PartialMediaFailureDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PartialMediaFailureDetected += x, x => _data.PartialMediaFailureDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Media.RateChangedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RateChanged += x, x => _data.RateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SeekCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VolumeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaTransportControlsEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.MediaTransportControls _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaTransportControlsEvents(global::Windows.UI.Xaml.Controls.MediaTransportControls data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args)> ThumbnailRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ThumbnailRequested += x, x => _data.ThumbnailRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuFlyoutItemEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.MenuFlyoutItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuFlyoutItemEvents(global::Windows.UI.Xaml.Controls.MenuFlyoutItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.NavigationView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationViewEvents(global::Windows.UI.Xaml.Controls.NavigationView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args)> BackRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args)> DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args)> ItemInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, object args)> PaneClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args)> PaneClosing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, object args)> PaneOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, object args)> PaneOpening => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args)> SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::Windows.UI.Xaml.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args)> PasswordChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PasswordChanging += x, x => _data.PasswordChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paste => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paste += x, x => _data.Paste -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.PickerFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPickerFlyoutEvents(global::Windows.UI.Xaml.Controls.PickerFlyout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args)> Confirmed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Confirmed += x, x => _data.Confirmed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPivotEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Pivot _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPivotEvents(global::Windows.UI.Xaml.Controls.Pivot data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PivotItemLoaded += x, x => _data.PivotItemLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PivotItemLoading += x, x => _data.PivotItemLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemUnloaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PivotItemUnloaded += x, x => _data.PivotItemUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemUnloading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PivotItemUnloading += x, x => _data.PivotItemUnloading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRatingControlEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.RatingControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRatingControlEvents(global::Windows.UI.Xaml.Controls.RatingControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RatingControl sender, object args)> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RatingControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RatingControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRefreshContainerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.RefreshContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRefreshContainerEvents(global::Windows.UI.Xaml.Controls.RefreshContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)> RefreshRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRefreshVisualizerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.RefreshVisualizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRefreshVisualizerEvents(global::Windows.UI.Xaml.Controls.RefreshVisualizer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)> RefreshRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args)> RefreshStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RefreshStateChanged += x, x => _data.RefreshStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichEditBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.RichEditBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichEditBoxEvents(global::Windows.UI.Xaml.Controls.RichEditBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)> CandidateWindowBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args)> ContentLinkChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLinkChanged += x, x => _data.ContentLinkChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)> ContentLinkInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLinkInvoked += x, x => _data.ContentLinkInvoked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)> CopyingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)> CuttingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paste => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paste += x, x => _data.Paste -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args)> SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args)> TextChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)> TextCompositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)> TextCompositionEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)> TextCompositionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBlockEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.RichTextBlock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBlockEvents(global::Windows.UI.Xaml.Controls.RichTextBlock data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)> IsTextTrimmedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBlockOverflowEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.RichTextBlockOverflow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBlockOverflowEvents(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)> IsTextTrimmedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::Windows.UI.Xaml.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args)> AnchorRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AnchorRequested += x, x => _data.AnchorRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DirectManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.DirectManipulationCompleted += x, x => _data.DirectManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DirectManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.DirectManipulationStarted += x, x => _data.DirectManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ViewChanged += x, x => _data.ViewChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ViewChanging => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ViewChanging += x, x => _data.ViewChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSearchBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.SearchBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSearchBoxEvents(global::Windows.UI.Xaml.Controls.SearchBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args)> PrepareForFocusOnKeyboardInput => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrepareForFocusOnKeyboardInput += x, x => _data.PrepareForFocusOnKeyboardInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args)> QueryChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QueryChanged += x, x => _data.QueryChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args)> QuerySubmitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args)> ResultSuggestionChosen => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args)> SuggestionsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSemanticZoomEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.SemanticZoom _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSemanticZoomEvents(global::Windows.UI.Xaml.Controls.SemanticZoom data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ViewChangeCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ViewChangeCompleted += x, x => _data.ViewChangeCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ViewChangeStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ViewChangeStarted += x, x => _data.ViewChangeStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSettingsFlyoutEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.SettingsFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSettingsFlyoutEvents(global::Windows.UI.Xaml.Controls.SettingsFlyout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.BackClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackClick += x, x => _data.BackClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitButtonEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.SplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitButtonEvents(global::Windows.UI.Xaml.Controls.SplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args)> Click => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.SplitView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitViewEvents(global::Windows.UI.Xaml.Controls.SplitView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, object args)> PaneClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args)> PaneClosing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, object args)> PaneOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, object args)> PaneOpening => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStackPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.StackPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStackPanelEvents(global::Windows.UI.Xaml.Controls.StackPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSwapChainPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.SwapChainPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSwapChainPanelEvents(global::Windows.UI.Xaml.Controls.SwapChainPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args)> CompositionScaleChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CompositionScaleChanged += x, x => _data.CompositionScaleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSwipeItemEvents + { + private readonly global::Windows.UI.Xaml.Controls.SwipeItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSwipeItemEvents(global::Windows.UI.Xaml.Controls.SwipeItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Invoked += x, x => _data.Invoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBlockEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.TextBlock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBlockEvents(global::Windows.UI.Xaml.Controls.TextBlock data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)> IsTextTrimmedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::Windows.UI.Xaml.Controls.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args)> BeforeTextChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BeforeTextChanging += x, x => _data.BeforeTextChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)> CandidateWindowBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)> CopyingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)> CuttingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paste => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paste += x, x => _data.Paste -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args)> SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args)> TextChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)> TextCompositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)> TextCompositionEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)> TextCompositionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimePickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.TimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimePickerEvents(global::Windows.UI.Xaml.Controls.TimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args)> SelectedTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedTimeChanged += x, x => _data.SelectedTimeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TimeChanged += x, x => _data.TimeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimePickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.TimePickerFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimePickerFlyoutEvents(global::Windows.UI.Xaml.Controls.TimePickerFlyout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args)> TimePicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TimePicked += x, x => _data.TimePicked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleSplitButtonEvents : global::Windows.UI.Xaml.Controls.RxSplitButtonEvents + { + private readonly global::Windows.UI.Xaml.Controls.ToggleSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleSplitButtonEvents(global::Windows.UI.Xaml.Controls.ToggleSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args)> IsCheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsCheckedChanged += x, x => _data.IsCheckedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleSwitchEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.ToggleSwitch _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleSwitchEvents(global::Windows.UI.Xaml.Controls.ToggleSwitch data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Toggled += x, x => _data.Toggled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::Windows.UI.Xaml.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::Windows.UI.Xaml.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args)> Collapsed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args)> DragItemsCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args)> DragItemsStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args)> Expanding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Expanding += x, x => _data.Expanding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args)> ItemInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTwoPaneViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.TwoPaneView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTwoPaneViewEvents(global::Windows.UI.Xaml.Controls.TwoPaneView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TwoPaneView sender, object args)> ModeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TwoPaneView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TwoPaneView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ModeChanged += x, x => _data.ModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVirtualizingStackPanelEvents : global::Windows.UI.Xaml.Controls.Primitives.RxOrientedVirtualizingPanelEvents + { + private readonly global::Windows.UI.Xaml.Controls.VirtualizingStackPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVirtualizingStackPanelEvents(global::Windows.UI.Xaml.Controls.VirtualizingStackPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CleanUpVirtualizedItemEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CleanUpVirtualizedItemEvent += x, x => _data.CleanUpVirtualizedItemEvent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebViewEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.WebView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebViewEvents(global::Windows.UI.Xaml.Controls.WebView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.WebViewNavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.NotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args)> SeparateProcessLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SeparateProcessLost += x, x => _data.SeparateProcessLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + } +} + +namespace Windows.UI.Xaml.Controls.Maps +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCustomMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource item) => new RxCustomMapTileDataSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHttpMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource item) => new RxHttpMapTileDataSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLocalMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource item) => new RxLocalMapTileDataSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMapControlEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapControl item) => new RxMapControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMapControlDataHelperEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapControlDataHelper item) => new RxMapControlDataHelperEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMapElementsLayerEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer item) => new RxMapElementsLayerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMapSceneEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapScene item) => new RxMapSceneEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCustomMapTileDataSourceEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCustomMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args)> BitmapRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHttpMapTileDataSourceEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHttpMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)> UriRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLocalMapTileDataSourceEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLocalMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)> UriRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMapControlEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.MapControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMapControlEvents(global::Windows.UI.Xaml.Controls.Maps.MapControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args)> ActualCameraChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActualCameraChanged += x, x => _data.ActualCameraChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args)> ActualCameraChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActualCameraChanging += x, x => _data.ActualCameraChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> CenterChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CenterChanged += x, x => _data.CenterChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args)> CustomExperienceChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CustomExperienceChanged += x, x => _data.CustomExperienceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> HeadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadingChanged += x, x => _data.HeadingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> LoadingStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LoadingStatusChanged += x, x => _data.LoadingStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args)> MapContextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)> MapDoubleTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapDoubleTapped += x, x => _data.MapDoubleTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args)> MapElementClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args)> MapElementPointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args)> MapElementPointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)> MapHolding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapHolding += x, x => _data.MapHolding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args)> MapRightTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapRightTapped += x, x => _data.MapRightTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)> MapTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapTapped += x, x => _data.MapTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> PitchChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PitchChanged += x, x => _data.PitchChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)> TargetCameraChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> TransformOriginChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransformOriginChanged += x, x => _data.TransformOriginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> ZoomLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ZoomLevelChanged += x, x => _data.ZoomLevelChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMapControlDataHelperEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.MapControlDataHelper _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMapControlDataHelperEvents(global::Windows.UI.Xaml.Controls.Maps.MapControlDataHelper data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkClickEventArgs args)> BusinessLandmarkClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BusinessLandmarkClick += x, x => _data.BusinessLandmarkClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerEnteredEventArgs args)> BusinessLandmarkPointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerEnteredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerEnteredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BusinessLandmarkPointerEntered += x, x => _data.BusinessLandmarkPointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerExitedEventArgs args)> BusinessLandmarkPointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerExitedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerExitedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BusinessLandmarkPointerExited += x, x => _data.BusinessLandmarkPointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkRightTappedEventArgs args)> BusinessLandmarkRightTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkRightTappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkRightTappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BusinessLandmarkRightTapped += x, x => _data.BusinessLandmarkRightTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureClickEventArgs args)> TransitFeatureClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransitFeatureClick += x, x => _data.TransitFeatureClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerEnteredEventArgs args)> TransitFeaturePointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerEnteredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerEnteredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransitFeaturePointerEntered += x, x => _data.TransitFeaturePointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerExitedEventArgs args)> TransitFeaturePointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerExitedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerExitedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransitFeaturePointerExited += x, x => _data.TransitFeaturePointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureRightTappedEventArgs args)> TransitFeatureRightTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureRightTappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureRightTappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransitFeatureRightTapped += x, x => _data.TransitFeatureRightTapped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMapElementsLayerEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMapElementsLayerEvents(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args)> MapContextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args)> MapElementClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args)> MapElementPointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args)> MapElementPointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMapSceneEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.MapScene _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMapSceneEvents(global::Windows.UI.Xaml.Controls.Maps.MapScene data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)> TargetCameraChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + } +} + +namespace Windows.UI.Xaml.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCarouselPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.CarouselPanel item) => new RxCarouselPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxColorSpectrumEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum item) => new RxColorSpectrumEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFlyoutBaseEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase item) => new RxFlyoutBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIScrollSnapPointsInfoEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo item) => new RxIScrollSnapPointsInfoEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLoopingSelectorEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.LoopingSelector item) => new RxLoopingSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLoopingSelectorPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.LoopingSelectorPanel item) => new RxLoopingSelectorPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxOrientedVirtualizingPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel item) => new RxOrientedVirtualizingPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPivotPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.PivotPanel item) => new RxPivotPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::Windows.UI.Xaml.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCarouselPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.CarouselPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCarouselPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.CarouselPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxColorSpectrumEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxColorSpectrumEvents(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)> ColorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFlyoutBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFlyoutBaseEvents(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIScrollSnapPointsInfoEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIScrollSnapPointsInfoEvents(global::Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLoopingSelectorEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.LoopingSelector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLoopingSelectorEvents(global::Windows.UI.Xaml.Controls.Primitives.LoopingSelector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLoopingSelectorPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.LoopingSelectorPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLoopingSelectorPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.LoopingSelectorPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxOrientedVirtualizingPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxOrientedVirtualizingPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPivotPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.PivotPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPivotPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.PivotPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::Windows.UI.Xaml.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::Windows.UI.Xaml.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::Windows.UI.Xaml.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::Windows.UI.Xaml.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::Windows.UI.Xaml.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::Windows.UI.Xaml.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::Windows.UI.Xaml.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::Windows.UI.Xaml.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace Windows.UI.Xaml.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::Windows.UI.Xaml.Data.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::Windows.UI.Xaml.Data.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::Windows.UI.Xaml.Data.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Data.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace Windows.UI.Xaml.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentLinkEvents Events(this global::Windows.UI.Xaml.Documents.ContentLink item) => new RxContentLinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::Windows.UI.Xaml.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextElementEvents Events(this global::Windows.UI.Xaml.Documents.TextElement item) => new RxTextElementEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentLinkEvents : global::Windows.UI.Xaml.Documents.RxTextElementEvents + { + private readonly global::Windows.UI.Xaml.Documents.ContentLink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentLinkEvents(global::Windows.UI.Xaml.Documents.ContentLink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Invoked += x, x => _data.Invoked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::Windows.UI.Xaml.Documents.RxTextElementEvents + { + private readonly global::Windows.UI.Xaml.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::Windows.UI.Xaml.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args)> Click => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextElementEvents + { + private readonly global::Windows.UI.Xaml.Documents.TextElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextElementEvents(global::Windows.UI.Xaml.Documents.TextElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)> AccessKeyDisplayDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)> AccessKeyDisplayRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)> AccessKeyInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + } +} + +namespace Windows.UI.Xaml.Hosting +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDesignerAppManagerEvents Events(this global::Windows.UI.Xaml.Hosting.DesignerAppManager item) => new RxDesignerAppManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDesktopWindowXamlSourceEvents Events(this global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource item) => new RxDesktopWindowXamlSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDesignerAppManagerEvents + { + private readonly global::Windows.UI.Xaml.Hosting.DesignerAppManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDesignerAppManagerEvents(global::Windows.UI.Xaml.Hosting.DesignerAppManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Hosting.DesignerAppManager sender, global::Windows.UI.Xaml.Hosting.DesignerAppExitedEventArgs args)> DesignerAppExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Hosting.DesignerAppManager sender, global::Windows.UI.Xaml.Hosting.DesignerAppExitedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Hosting.DesignerAppManager sender, global::Windows.UI.Xaml.Hosting.DesignerAppExitedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DesignerAppExited += x, x => _data.DesignerAppExited -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDesktopWindowXamlSourceEvents + { + private readonly global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDesktopWindowXamlSourceEvents(global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceGotFocusEventArgs args)> GotFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceGotFocusEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceGotFocusEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceTakeFocusRequestedEventArgs args)> TakeFocusRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceTakeFocusRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceTakeFocusRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TakeFocusRequested += x, x => _data.TakeFocusRequested -= x); + } +} + +namespace Windows.UI.Xaml.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxKeyboardAcceleratorEvents Events(this global::Windows.UI.Xaml.Input.KeyboardAccelerator item) => new RxKeyboardAcceleratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlUICommandEvents Events(this global::Windows.UI.Xaml.Input.XamlUICommand item) => new RxXamlUICommandEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxKeyboardAcceleratorEvents + { + private readonly global::Windows.UI.Xaml.Input.KeyboardAccelerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxKeyboardAcceleratorEvents(global::Windows.UI.Xaml.Input.KeyboardAccelerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Invoked += x, x => _data.Invoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlUICommandEvents + { + private readonly global::Windows.UI.Xaml.Input.XamlUICommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlUICommandEvents(global::Windows.UI.Xaml.Input.XamlUICommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args)> CanExecuteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CanExecuteRequested += x, x => _data.CanExecuteRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args)> ExecuteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ExecuteRequested += x, x => _data.ExecuteRequested -= x); + } +} + +namespace Windows.UI.Xaml.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIBindableObservableVectorEvents Events(this global::Windows.UI.Xaml.Interop.IBindableObservableVector item) => new RxIBindableObservableVectorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIBindableObservableVectorEvents + { + private readonly global::Windows.UI.Xaml.Interop.IBindableObservableVector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIBindableObservableVectorEvents(global::Windows.UI.Xaml.Interop.IBindableObservableVector data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Interop.IBindableObservableVector vector, object e)> VectorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Interop.IBindableObservableVector vector, object e) => eventHandler((vector, e)); + return Handler; + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + } +} + +namespace Windows.UI.Xaml.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageBrushEvents Events(this global::Windows.UI.Xaml.Media.ImageBrush item) => new RxImageBrushEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLoadedImageSurfaceEvents Events(this global::Windows.UI.Xaml.Media.LoadedImageSurface item) => new RxLoadedImageSurfaceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageBrushEvents + { + private readonly global::Windows.UI.Xaml.Media.ImageBrush _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageBrushEvents(global::Windows.UI.Xaml.Media.ImageBrush data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLoadedImageSurfaceEvents + { + private readonly global::Windows.UI.Xaml.Media.LoadedImageSurface _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLoadedImageSurfaceEvents(global::Windows.UI.Xaml.Media.LoadedImageSurface data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args)> LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace Windows.UI.Xaml.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxConnectedAnimationEvents Events(this global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation item) => new RxConnectedAnimationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::Windows.UI.Xaml.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxConnectedAnimationEvents + { + private readonly global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxConnectedAnimationEvents(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents + { + private readonly global::Windows.UI.Xaml.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::Windows.UI.Xaml.Media.Animation.Timeline data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } +} + +namespace Windows.UI.Xaml.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapImageEvents Events(this global::Windows.UI.Xaml.Media.Imaging.BitmapImage item) => new RxBitmapImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSvgImageSourceEvents Events(this global::Windows.UI.Xaml.Media.Imaging.SvgImageSource item) => new RxSvgImageSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapImageEvents + { + private readonly global::Windows.UI.Xaml.Media.Imaging.BitmapImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapImageEvents(global::Windows.UI.Xaml.Media.Imaging.BitmapImage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSvgImageSourceEvents + { + private readonly global::Windows.UI.Xaml.Media.Imaging.SvgImageSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSvgImageSourceEvents(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args)> OpenFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + } +} + +namespace Windows.UI.Xaml.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintDocumentEvents Events(this global::Windows.UI.Xaml.Printing.PrintDocument item) => new RxPrintDocumentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintDocumentEvents + { + private readonly global::Windows.UI.Xaml.Printing.PrintDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintDocumentEvents(global::Windows.UI.Xaml.Printing.PrintDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddPages => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Printing.AddPagesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddPages += x, x => _data.AddPages -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPreviewPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Printing.GetPreviewPageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPreviewPage += x, x => _data.GetPreviewPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paginate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Printing.PaginateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paginate += x, x => _data.Paginate -= x); + } +} + +namespace Windows.Web.Http.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHttpDiagnosticProviderEvents Events(this global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider item) => new RxHttpDiagnosticProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHttpDiagnosticProviderEvents + { + private readonly global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHttpDiagnosticProviderEvents(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestResponseCompletedEventArgs args)> RequestResponseCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestResponseCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestResponseCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RequestResponseCompleted += x, x => _data.RequestResponseCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestSentEventArgs args)> RequestSent => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestSentEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestSentEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RequestSent += x, x => _data.RequestSent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderResponseReceivedEventArgs args)> ResponseReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderResponseReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderResponseReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResponseReceived += x, x => _data.ResponseReceived -= x); + } +} + +namespace Windows.Web.Http.Filters +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHttpBaseProtocolFilterEvents Events(this global::Windows.Web.Http.Filters.HttpBaseProtocolFilter item) => new RxHttpBaseProtocolFilterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHttpBaseProtocolFilterEvents + { + private readonly global::Windows.Web.Http.Filters.HttpBaseProtocolFilter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHttpBaseProtocolFilterEvents(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args)> ServerCustomValidationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + } +} + +namespace Windows.Web.UI +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIWebViewControlEvents Events(this global::Windows.Web.UI.IWebViewControl item) => new RxIWebViewControlEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIWebViewControlEvents + { + private readonly global::Windows.Web.UI.IWebViewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIWebViewControlEvents(global::Windows.Web.UI.IWebViewControl data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)> ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + } +} + +namespace Windows.Web.UI.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebViewControlEvents Events(this global::Windows.Web.UI.Interop.WebViewControl item) => new RxWebViewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebViewControlProcessEvents Events(this global::Windows.Web.UI.Interop.WebViewControlProcess item) => new RxWebViewControlProcessEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebViewControlEvents + { + private readonly global::Windows.Web.UI.Interop.WebViewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebViewControlEvents(global::Windows.Web.UI.Interop.WebViewControl data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args)> AcceleratorKeyPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AcceleratorKeyPressed += x, x => _data.AcceleratorKeyPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, object args)> GotFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, object args)> LostFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args)> MoveFocusRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MoveFocusRequested += x, x => _data.MoveFocusRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)> ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebViewControlProcessEvents + { + private readonly global::Windows.Web.UI.Interop.WebViewControlProcess _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebViewControlProcessEvents(global::Windows.Web.UI.Interop.WebViewControlProcess data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args)> ProcessExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProcessExited += x, x => _data.ProcessExited -= x); + } +} + +namespace Windows.ApplicationModel.Calls +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PhoneCallManagerCallStateChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Calls.PhoneCallManager.CallStateChanged += x, x => global::Windows.ApplicationModel.Calls.PhoneCallManager.CallStateChanged -= x); + } +} + +namespace Windows.ApplicationModel.Chat +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RcsManagerTransportListChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged += x, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged -= x); + } +} + +namespace Windows.ApplicationModel.Core +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationBackgroundActivated => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated += x, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationEnteredBackground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.EnteredBackgroundEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationExiting => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationLeavingBackground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.LeavingBackgroundEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationResuming => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationSuspending => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.SuspendingEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationUnhandledErrorDetected => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected += x, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected -= x); + } +} + +namespace Windows.ApplicationModel.DataTransfer +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ClipboardContentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ClipboardHistoryChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.DataTransfer.ClipboardHistoryChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.DataTransfer.ClipboardHistoryChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ClipboardHistoryEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ClipboardRoamingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged -= x); + } +} + +namespace Windows.Foundation.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AsyncCausalityTracerTracingStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged += x, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged -= x); + } +} + +namespace Windows.Gaming.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ArcadeStickArcadeStickAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.ArcadeStick>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ArcadeStickArcadeStickRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.ArcadeStick>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FlightStickFlightStickAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.FlightStick>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FlightStickFlightStickRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.FlightStick>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GamepadGamepadAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.Gamepad>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded += x, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GamepadGamepadRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.Gamepad>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved += x, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RacingWheelRacingWheelAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RacingWheel>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RacingWheelRacingWheelRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RacingWheel>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RawGameControllerRawGameControllerAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RawGameController>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RawGameControllerRawGameControllerRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RawGameController>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable UINavigationControllerUINavigationControllerAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.UINavigationController>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable UINavigationControllerUINavigationControllerRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.UINavigationController>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved -= x); + } +} + +namespace Windows.Gaming.Preview.GamesEnumeration +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GameListGameAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Gaming.Preview.GamesEnumeration.GameListEntry game) => eventHandler(game); + return Handler; + }, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameAdded += x, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GameListGameRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(string identifier) => eventHandler(identifier); + return Handler; + }, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameRemoved += x, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GameListGameUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Gaming.Preview.GamesEnumeration.GameListEntry game) => eventHandler(game); + return Handler; + }, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameUpdated += x, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameUpdated -= x); + } +} + +namespace Windows.Gaming.UI +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GameBarIsInputRedirectedChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged += x, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GameBarVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged += x, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged -= x); + } +} + +namespace Windows.Graphics.Display +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> DisplayInformationDisplayContentsInvalidated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable DisplayPropertiesColorProfileChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable DisplayPropertiesDisplayContentsInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable DisplayPropertiesLogicalDpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable DisplayPropertiesOrientationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable DisplayPropertiesStereoEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged -= x); + } +} + +namespace Windows.Graphics.Holographic +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable HolographicSpaceIsAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged += x, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged -= x); + } +} + +namespace Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlChannelDownPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.ChannelDownPressed += x, x => global::Windows.Media.MediaControl.ChannelDownPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlChannelUpPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.ChannelUpPressed += x, x => global::Windows.Media.MediaControl.ChannelUpPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlFastForwardPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.FastForwardPressed += x, x => global::Windows.Media.MediaControl.FastForwardPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlNextTrackPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.NextTrackPressed += x, x => global::Windows.Media.MediaControl.NextTrackPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlPausePressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.PausePressed += x, x => global::Windows.Media.MediaControl.PausePressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlPlayPauseTogglePressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.PlayPauseTogglePressed += x, x => global::Windows.Media.MediaControl.PlayPauseTogglePressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlPlayPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.PlayPressed += x, x => global::Windows.Media.MediaControl.PlayPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlPreviousTrackPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.PreviousTrackPressed += x, x => global::Windows.Media.MediaControl.PreviousTrackPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlRecordPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.RecordPressed += x, x => global::Windows.Media.MediaControl.RecordPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlRewindPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.RewindPressed += x, x => global::Windows.Media.MediaControl.RewindPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlSoundLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.SoundLevelChanged += x, x => global::Windows.Media.MediaControl.SoundLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlStopPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.StopPressed += x, x => global::Windows.Media.MediaControl.StopPressed -= x); + } +} + +namespace Windows.Media.Core.Preview +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SoundLevelBrokerSoundLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged += x, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged -= x); + } +} + +namespace Windows.Media.Devices +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaDeviceDefaultAudioCaptureDeviceChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Devices.DefaultAudioCaptureDeviceChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Media.Devices.DefaultAudioCaptureDeviceChangedEventArgs args) => eventHandler(args); + return Handler; + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaDeviceDefaultAudioRenderDeviceChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Devices.DefaultAudioRenderDeviceChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Media.Devices.DefaultAudioRenderDeviceChangedEventArgs args) => eventHandler(args); + return Handler; + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged -= x); + } +} + +namespace Windows.Media.Playback +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BackgroundMediaPlayerMessageReceivedFromBackground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BackgroundMediaPlayerMessageReceivedFromForeground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground -= x); + } +} + +namespace Windows.Networking.Connectivity +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable NetworkInformationNetworkStatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged += x, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged -= x); + } +} + +namespace Windows.Networking.NetworkOperators +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ESimManagerServiceInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged += x, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged -= x); + } +} + +namespace Windows.Networking.Proximity +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PeerFinderConnectionRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Networking.Proximity.ConnectionRequestedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Networking.Proximity.ConnectionRequestedEventArgs args) => eventHandler(args); + return Handler; + }, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested += x, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PeerFinderTriggeredConnectionStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Networking.Proximity.TriggeredConnectionStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Networking.Proximity.TriggeredConnectionStateChangedEventArgs args) => eventHandler(args); + return Handler; + }, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged += x, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged -= x); + } +} + +namespace Windows.Networking.PushNotifications +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PushNotificationChannelManagerChannelsRevoked => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Networking.PushNotifications.PushNotificationChannelsRevokedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Networking.PushNotifications.PushNotificationChannelsRevokedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Networking.PushNotifications.PushNotificationChannelManager.ChannelsRevoked += x, x => global::Windows.Networking.PushNotifications.PushNotificationChannelManager.ChannelsRevoked -= x); + } +} + +namespace Windows.Perception.Spatial +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SpatialStageFrameOfReferenceCurrentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged += x, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged -= x); + } +} + +namespace Windows.Phone.System.Power +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerPowerSavingModeChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged += x, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged -= x); + } +} + +namespace Windows.Phone.UI.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable HardwareButtonsBackPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.BackPressedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Phone.UI.Input.BackPressedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable HardwareButtonsCameraHalfPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.CameraEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable HardwareButtonsCameraPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.CameraEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable HardwareButtonsCameraReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.CameraEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased -= x); + } +} + +namespace Windows.Security.Authentication.Identity.Provider +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SecondaryAuthenticationFactorAuthenticationAuthenticationStageChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged += x, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged -= x); + } +} + +namespace Windows.Security.EnterpriseData +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ProtectionPolicyManagerPolicyChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.PolicyChanged += x, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.PolicyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ProtectionPolicyManagerProtectedAccessResumed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Security.EnterpriseData.ProtectedAccessResumedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Security.EnterpriseData.ProtectedAccessResumedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedAccessResumed += x, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedAccessResumed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ProtectionPolicyManagerProtectedAccessSuspending => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Security.EnterpriseData.ProtectedAccessSuspendingEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Security.EnterpriseData.ProtectedAccessSuspendingEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedAccessSuspending += x, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedAccessSuspending -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ProtectionPolicyManagerProtectedContentRevoked => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Security.EnterpriseData.ProtectedContentRevokedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Security.EnterpriseData.ProtectedContentRevokedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedContentRevoked += x, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedContentRevoked -= x); + } +} + +namespace Windows.System +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MemoryManagerAppMemoryUsageDecreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MemoryManagerAppMemoryUsageIncreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MemoryManagerAppMemoryUsageLimitChanging => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.System.AppMemoryUsageLimitChangingEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.System.AppMemoryUsageLimitChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging += x, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable UserDeviceAssociationUserDeviceAssociationChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.System.UserDeviceAssociationChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.System.UserDeviceAssociationChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged += x, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged -= x); + } +} + +namespace Windows.System.Power +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BackgroundEnergyManagerRecentEnergyUsageIncreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BackgroundEnergyManagerRecentEnergyUsageReturnedToLow => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ForegroundEnergyManagerRecentEnergyUsageIncreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ForegroundEnergyManagerRecentEnergyUsageReturnedToLow => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerBatteryStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged += x, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged += x, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerPowerSupplyStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged += x, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerRemainingChargePercentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged += x, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerRemainingDischargeTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged += x, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged -= x); + } +} + +namespace Windows.System.Profile +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PlatformDiagnosticsAndUsageDataSettingsCollectionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged += x, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemSetupInfoOutOfBoxExperienceStateChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged += x, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WindowsIntegrityPolicyPolicyChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged += x, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged -= x); + } +} + +namespace Windows.System.Update +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemUpdateManagerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Update.SystemUpdateManager.StateChanged += x, x => global::Windows.System.Update.SystemUpdateManager.StateChanged -= x); + } +} + +namespace Windows.System.UserProfile +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable UserInformationAccountPictureChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.UserProfile.UserInformation.AccountPictureChanged += x, x => global::Windows.System.UserProfile.UserInformation.AccountPictureChanged -= x); + } +} + +namespace Windows.UI.ViewManagement +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ProjectionManagerProjectionDisplayAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged += x, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged -= x); + } +} + +namespace Windows.UI.WebUI +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationActivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs eventArgs) => eventHandler(eventArgs); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.Activated += x, x => global::Windows.UI.WebUI.WebUIApplication.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationBackgroundActivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs eventArgs) => eventHandler(eventArgs); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated += x, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationEnteredBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.IEnteredBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationLeavingBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.ILeavingBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationNavigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.WebUI.IWebUINavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.Navigated += x, x => global::Windows.UI.WebUI.WebUIApplication.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationNewWebUIViewCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.WebUI.NewWebUIViewCreatedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.WebUI.NewWebUIViewCreatedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated += x, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationResuming => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.Resuming += x, x => global::Windows.UI.WebUI.WebUIApplication.Resuming -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationSuspending => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.ISuspendingEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.Suspending += x, x => global::Windows.UI.WebUI.WebUIApplication.Suspending -= x); + } +} + +namespace Windows.UI.Xaml.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AccessKeyManagerIsDisplayModeEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object args) => eventHandler(args); + return Handler; + }, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged += x, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerGettingFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.GettingFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerGotFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.FocusManagerGotFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerGotFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerLosingFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.LosingFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerLostFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.FocusManagerLostFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerLostFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus -= x); + } +} + +namespace Windows.UI.Xaml.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Media.RenderedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Media.RenderedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetSurfaceContentsLost => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/uap10.0.17763.approved.txt new file mode 100644 index 0000000..da39641 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/uap10.0.17763.approved.txt @@ -0,0 +1,23957 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Windows.ApplicationModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageCatalogEvents Events(this global::Windows.ApplicationModel.PackageCatalog item) => new RxPackageCatalogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageCatalogEvents + { + private readonly global::Windows.ApplicationModel.PackageCatalog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageCatalogEvents(global::Windows.ApplicationModel.PackageCatalog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args)> PackageContentGroupStaging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageContentGroupStaging += x, x => _data.PackageContentGroupStaging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args)> PackageInstalling => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageInstalling += x, x => _data.PackageInstalling -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args)> PackageStaging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageStaging += x, x => _data.PackageStaging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args)> PackageStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args)> PackageUninstalling => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args)> PackageUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + } +} + +namespace Windows.ApplicationModel.Activation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplashScreenEvents Events(this global::Windows.ApplicationModel.Activation.SplashScreen item) => new RxSplashScreenEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplashScreenEvents + { + private readonly global::Windows.ApplicationModel.Activation.SplashScreen _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplashScreenEvents(global::Windows.ApplicationModel.Activation.SplashScreen data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Activation.SplashScreen sender, object args)> Dismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Activation.SplashScreen sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Activation.SplashScreen sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); + } +} + +namespace Windows.ApplicationModel.AppExtensions +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppExtensionCatalogEvents Events(this global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog item) => new RxAppExtensionCatalogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppExtensionCatalogEvents + { + private readonly global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppExtensionCatalogEvents(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args)> PackageInstalled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageInstalled += x, x => _data.PackageInstalled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args)> PackageStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args)> PackageUninstalling => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args)> PackageUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageUpdated += x, x => _data.PackageUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args)> PackageUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + } +} + +namespace Windows.ApplicationModel.Appointments +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppointmentCalendarSyncManagerEvents Events(this global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager item) => new RxAppointmentCalendarSyncManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppointmentStoreEvents Events(this global::Windows.ApplicationModel.Appointments.AppointmentStore item) => new RxAppointmentStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppointmentCalendarSyncManagerEvents + { + private readonly global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppointmentCalendarSyncManagerEvents(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppointmentStoreEvents + { + private readonly global::Windows.ApplicationModel.Appointments.AppointmentStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppointmentStoreEvents(global::Windows.ApplicationModel.Appointments.AppointmentStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args)> StoreChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + } +} + +namespace Windows.ApplicationModel.Appointments.DataProvider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppointmentDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection item) => new RxAppointmentDataProviderConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppointmentDataProviderConnectionEvents + { + private readonly global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppointmentDataProviderConnectionEvents(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args)> CancelMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CancelMeetingRequested += x, x => _data.CancelMeetingRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args)> CreateOrUpdateAppointmentRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CreateOrUpdateAppointmentRequested += x, x => _data.CreateOrUpdateAppointmentRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args)> ForwardMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args)> ProposeNewTimeForMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args)> SyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args)> UpdateMeetingResponseRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + } +} + +namespace Windows.ApplicationModel.AppService +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppServiceConnectionEvents Events(this global::Windows.ApplicationModel.AppService.AppServiceConnection item) => new RxAppServiceConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppServiceConnectionEvents + { + private readonly global::Windows.ApplicationModel.AppService.AppServiceConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppServiceConnectionEvents(global::Windows.ApplicationModel.AppService.AppServiceConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args)> RequestReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args)> ServiceClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServiceClosed += x, x => _data.ServiceClosed -= x); + } +} + +namespace Windows.ApplicationModel.Background +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBackgroundTaskRegistrationEvents Events(this global::Windows.ApplicationModel.Background.BackgroundTaskRegistration item) => new RxBackgroundTaskRegistrationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBackgroundTaskRegistrationGroupEvents Events(this global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup item) => new RxBackgroundTaskRegistrationGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIBackgroundTaskInstanceEvents Events(this global::Windows.ApplicationModel.Background.IBackgroundTaskInstance item) => new RxIBackgroundTaskInstanceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIBackgroundTaskRegistrationEvents Events(this global::Windows.ApplicationModel.Background.IBackgroundTaskRegistration item) => new RxIBackgroundTaskRegistrationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBackgroundTaskRegistrationEvents + { + private readonly global::Windows.ApplicationModel.Background.BackgroundTaskRegistration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBackgroundTaskRegistrationEvents(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args)> Progress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Progress += x, x => _data.Progress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBackgroundTaskRegistrationGroupEvents + { + private readonly global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBackgroundTaskRegistrationGroupEvents(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args)> BackgroundActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BackgroundActivated += x, x => _data.BackgroundActivated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIBackgroundTaskInstanceEvents + { + private readonly global::Windows.ApplicationModel.Background.IBackgroundTaskInstance _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIBackgroundTaskInstanceEvents(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason)> Canceled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); + return Handler; + }, x => _data.Canceled += x, x => _data.Canceled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIBackgroundTaskRegistrationEvents + { + private readonly global::Windows.ApplicationModel.Background.IBackgroundTaskRegistration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIBackgroundTaskRegistrationEvents(global::Windows.ApplicationModel.Background.IBackgroundTaskRegistration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args)> Progress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Progress += x, x => _data.Progress -= x); + } +} + +namespace Windows.ApplicationModel.Calls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLockScreenCallUIEvents Events(this global::Windows.ApplicationModel.Calls.LockScreenCallUI item) => new RxLockScreenCallUIEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPhoneLineEvents Events(this global::Windows.ApplicationModel.Calls.PhoneLine item) => new RxPhoneLineEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPhoneLineWatcherEvents Events(this global::Windows.ApplicationModel.Calls.PhoneLineWatcher item) => new RxPhoneLineWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVoipCallCoordinatorEvents Events(this global::Windows.ApplicationModel.Calls.VoipCallCoordinator item) => new RxVoipCallCoordinatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVoipPhoneCallEvents Events(this global::Windows.ApplicationModel.Calls.VoipPhoneCall item) => new RxVoipPhoneCallEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLockScreenCallUIEvents + { + private readonly global::Windows.ApplicationModel.Calls.LockScreenCallUI _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLockScreenCallUIEvents(global::Windows.ApplicationModel.Calls.LockScreenCallUI data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, global::Windows.ApplicationModel.Calls.LockScreenCallEndRequestedEventArgs args)> EndRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, global::Windows.ApplicationModel.Calls.LockScreenCallEndRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, global::Windows.ApplicationModel.Calls.LockScreenCallEndRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EndRequested += x, x => _data.EndRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPhoneLineEvents + { + private readonly global::Windows.ApplicationModel.Calls.PhoneLine _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPhoneLineEvents(global::Windows.ApplicationModel.Calls.PhoneLine data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLine sender, object args)> LineChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLine sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLine sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LineChanged += x, x => _data.LineChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPhoneLineWatcherEvents + { + private readonly global::Windows.ApplicationModel.Calls.PhoneLineWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPhoneLineWatcherEvents(global::Windows.ApplicationModel.Calls.PhoneLineWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)> LineAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LineAdded += x, x => _data.LineAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)> LineRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LineRemoved += x, x => _data.LineRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)> LineUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LineUpdated += x, x => _data.LineUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVoipCallCoordinatorEvents + { + private readonly global::Windows.ApplicationModel.Calls.VoipCallCoordinator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVoipCallCoordinatorEvents(global::Windows.ApplicationModel.Calls.VoipCallCoordinator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipCallCoordinator sender, global::Windows.ApplicationModel.Calls.MuteChangeEventArgs args)> MuteStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipCallCoordinator sender, global::Windows.ApplicationModel.Calls.MuteChangeEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipCallCoordinator sender, global::Windows.ApplicationModel.Calls.MuteChangeEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MuteStateChanged += x, x => _data.MuteStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVoipPhoneCallEvents + { + private readonly global::Windows.ApplicationModel.Calls.VoipPhoneCall _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVoipPhoneCallEvents(global::Windows.ApplicationModel.Calls.VoipPhoneCall data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallAnswerEventArgs args)> AnswerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallAnswerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallAnswerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AnswerRequested += x, x => _data.AnswerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)> EndRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EndRequested += x, x => _data.EndRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)> HoldRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HoldRequested += x, x => _data.HoldRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallRejectEventArgs args)> RejectRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallRejectEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallRejectEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RejectRequested += x, x => _data.RejectRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)> ResumeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResumeRequested += x, x => _data.ResumeRequested -= x); + } +} + +namespace Windows.ApplicationModel.Chat +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxChatConversationEvents Events(this global::Windows.ApplicationModel.Chat.ChatConversation item) => new RxChatConversationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxChatMessageStoreEvents Events(this global::Windows.ApplicationModel.Chat.ChatMessageStore item) => new RxChatMessageStoreEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRcsEndUserMessageManagerEvents Events(this global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager item) => new RxRcsEndUserMessageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRcsTransportEvents Events(this global::Windows.ApplicationModel.Chat.RcsTransport item) => new RxRcsTransportEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxChatConversationEvents + { + private readonly global::Windows.ApplicationModel.Chat.ChatConversation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxChatConversationEvents(global::Windows.ApplicationModel.Chat.ChatConversation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args)> RemoteParticipantComposingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RemoteParticipantComposingChanged += x, x => _data.RemoteParticipantComposingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxChatMessageStoreEvents + { + private readonly global::Windows.ApplicationModel.Chat.ChatMessageStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxChatMessageStoreEvents(global::Windows.ApplicationModel.Chat.ChatMessageStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args)> MessageChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageChanged += x, x => _data.MessageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args)> StoreChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRcsEndUserMessageManagerEvents + { + private readonly global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRcsEndUserMessageManagerEvents(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args)> MessageAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageAvailableChanged += x, x => _data.MessageAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRcsTransportEvents + { + private readonly global::Windows.ApplicationModel.Chat.RcsTransport _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRcsTransportEvents(global::Windows.ApplicationModel.Chat.RcsTransport data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args)> ServiceKindSupportedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServiceKindSupportedChanged += x, x => _data.ServiceKindSupportedChanged -= x); + } +} + +namespace Windows.ApplicationModel.Contacts +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactListEvents Events(this global::Windows.ApplicationModel.Contacts.ContactList item) => new RxContactListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactListSyncManagerEvents Events(this global::Windows.ApplicationModel.Contacts.ContactListSyncManager item) => new RxContactListSyncManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactPanelEvents Events(this global::Windows.ApplicationModel.Contacts.ContactPanel item) => new RxContactPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactStoreEvents Events(this global::Windows.ApplicationModel.Contacts.ContactStore item) => new RxContactStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactListEvents + { + private readonly global::Windows.ApplicationModel.Contacts.ContactList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactListEvents(global::Windows.ApplicationModel.Contacts.ContactList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)> ContactChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactListSyncManagerEvents + { + private readonly global::Windows.ApplicationModel.Contacts.ContactListSyncManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactListSyncManagerEvents(global::Windows.ApplicationModel.Contacts.ContactListSyncManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactPanelEvents + { + private readonly global::Windows.ApplicationModel.Contacts.ContactPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactPanelEvents(global::Windows.ApplicationModel.Contacts.ContactPanel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args)> LaunchFullAppRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LaunchFullAppRequested += x, x => _data.LaunchFullAppRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactStoreEvents + { + private readonly global::Windows.ApplicationModel.Contacts.ContactStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactStoreEvents(global::Windows.ApplicationModel.Contacts.ContactStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)> ContactChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + } +} + +namespace Windows.ApplicationModel.Contacts.DataProvider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection item) => new RxContactDataProviderConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactDataProviderConnectionEvents + { + private readonly global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactDataProviderConnectionEvents(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args)> CreateOrUpdateContactRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CreateOrUpdateContactRequested += x, x => _data.CreateOrUpdateContactRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args)> DeleteContactRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DeleteContactRequested += x, x => _data.DeleteContactRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args)> ServerSearchReadBatchRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args)> SyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + } +} + +namespace Windows.ApplicationModel.Contacts.Provider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactPickerUIEvents Events(this global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI item) => new RxContactPickerUIEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactPickerUIEvents + { + private readonly global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactPickerUIEvents(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args)> ContactRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContactRemoved += x, x => _data.ContactRemoved -= x); + } +} + +namespace Windows.ApplicationModel.ConversationalAgent +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxActivationSignalDetectionConfigurationEvents Events(this global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration item) => new RxActivationSignalDetectionConfigurationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxConversationalAgentSessionEvents Events(this global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession item) => new RxConversationalAgentSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxActivationSignalDetectionConfigurationEvents + { + private readonly global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxActivationSignalDetectionConfigurationEvents(global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration sender, global::Windows.ApplicationModel.ConversationalAgent.DetectionConfigurationAvailabilityChangedEventArgs args)> AvailabilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration sender, global::Windows.ApplicationModel.ConversationalAgent.DetectionConfigurationAvailabilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration sender, global::Windows.ApplicationModel.ConversationalAgent.DetectionConfigurationAvailabilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxConversationalAgentSessionEvents + { + private readonly global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxConversationalAgentSessionEvents(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSessionInterruptedEventArgs args)> SessionInterrupted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSessionInterruptedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSessionInterruptedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionInterrupted += x, x => _data.SessionInterrupted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSignalDetectedEventArgs args)> SignalDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSignalDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSignalDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SignalDetected += x, x => _data.SignalDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSystemStateChangedEventArgs args)> SystemStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSystemStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSystemStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemStateChanged += x, x => _data.SystemStateChanged -= x); + } +} + +namespace Windows.ApplicationModel.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreApplicationViewEvents Events(this global::Windows.ApplicationModel.Core.CoreApplicationView item) => new RxCoreApplicationViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreApplicationViewTitleBarEvents Events(this global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar item) => new RxCoreApplicationViewTitleBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICoreApplicationUnhandledErrorEvents Events(this global::Windows.ApplicationModel.Core.ICoreApplicationUnhandledError item) => new RxICoreApplicationUnhandledErrorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreApplicationViewEvents + { + private readonly global::Windows.ApplicationModel.Core.CoreApplicationView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreApplicationViewEvents(global::Windows.ApplicationModel.Core.CoreApplicationView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args)> HostedViewClosing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HostedViewClosing += x, x => _data.HostedViewClosing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreApplicationViewTitleBarEvents + { + private readonly global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreApplicationViewTitleBarEvents(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)> IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)> LayoutMetricsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LayoutMetricsChanged += x, x => _data.LayoutMetricsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICoreApplicationUnhandledErrorEvents + { + private readonly global::Windows.ApplicationModel.Core.ICoreApplicationUnhandledError _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICoreApplicationUnhandledErrorEvents(global::Windows.ApplicationModel.Core.ICoreApplicationUnhandledError data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledErrorDetected => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledErrorDetected += x, x => _data.UnhandledErrorDetected -= x); + } +} + +namespace Windows.ApplicationModel.DataTransfer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataPackageEvents Events(this global::Windows.ApplicationModel.DataTransfer.DataPackage item) => new RxDataPackageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataTransferManagerEvents Events(this global::Windows.ApplicationModel.DataTransfer.DataTransferManager item) => new RxDataTransferManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataPackageEvents + { + private readonly global::Windows.ApplicationModel.DataTransfer.DataPackage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataPackageEvents(global::Windows.ApplicationModel.DataTransfer.DataPackage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args)> Destroyed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args)> OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args)> ShareCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShareCanceled += x, x => _data.ShareCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args)> ShareCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShareCompleted += x, x => _data.ShareCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataTransferManagerEvents + { + private readonly global::Windows.ApplicationModel.DataTransfer.DataTransferManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataTransferManagerEvents(global::Windows.ApplicationModel.DataTransfer.DataTransferManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args)> DataRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataRequested += x, x => _data.DataRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args)> ShareProvidersRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShareProvidersRequested += x, x => _data.ShareProvidersRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args)> TargetApplicationChosen => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TargetApplicationChosen += x, x => _data.TargetApplicationChosen -= x); + } +} + +namespace Windows.ApplicationModel.DataTransfer.DragDrop.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreDragDropManagerEvents Events(this global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager item) => new RxCoreDragDropManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreDragDropManagerEvents + { + private readonly global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreDragDropManagerEvents(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args)> TargetRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TargetRequested += x, x => _data.TargetRequested -= x); + } +} + +namespace Windows.ApplicationModel.Email +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEmailMailboxEvents Events(this global::Windows.ApplicationModel.Email.EmailMailbox item) => new RxEmailMailboxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEmailMailboxSyncManagerEvents Events(this global::Windows.ApplicationModel.Email.EmailMailboxSyncManager item) => new RxEmailMailboxSyncManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEmailMailboxEvents + { + private readonly global::Windows.ApplicationModel.Email.EmailMailbox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEmailMailboxEvents(global::Windows.ApplicationModel.Email.EmailMailbox data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args)> MailboxChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MailboxChanged += x, x => _data.MailboxChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEmailMailboxSyncManagerEvents + { + private readonly global::Windows.ApplicationModel.Email.EmailMailboxSyncManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEmailMailboxSyncManagerEvents(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + } +} + +namespace Windows.ApplicationModel.Email.DataProvider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEmailDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection item) => new RxEmailDataProviderConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEmailDataProviderConnectionEvents + { + private readonly global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEmailDataProviderConnectionEvents(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args)> CreateFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CreateFolderRequested += x, x => _data.CreateFolderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args)> DeleteFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DeleteFolderRequested += x, x => _data.DeleteFolderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args)> DownloadAttachmentRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadAttachmentRequested += x, x => _data.DownloadAttachmentRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args)> DownloadMessageRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadMessageRequested += x, x => _data.DownloadMessageRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args)> EmptyFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EmptyFolderRequested += x, x => _data.EmptyFolderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args)> ForwardMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args)> GetAutoReplySettingsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GetAutoReplySettingsRequested += x, x => _data.GetAutoReplySettingsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args)> MailboxSyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MailboxSyncRequested += x, x => _data.MailboxSyncRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args)> MoveFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MoveFolderRequested += x, x => _data.MoveFolderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args)> ProposeNewTimeForMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args)> ResolveRecipientsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResolveRecipientsRequested += x, x => _data.ResolveRecipientsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args)> ServerSearchReadBatchRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args)> SetAutoReplySettingsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SetAutoReplySettingsRequested += x, x => _data.SetAutoReplySettingsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args)> UpdateMeetingResponseRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args)> ValidateCertificatesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValidateCertificatesRequested += x, x => _data.ValidateCertificatesRequested -= x); + } +} + +namespace Windows.ApplicationModel.ExtendedExecution +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExtendedExecutionSessionEvents Events(this global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionSession item) => new RxExtendedExecutionSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExtendedExecutionSessionEvents + { + private readonly global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExtendedExecutionSessionEvents(global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Revoked => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionRevokedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionRevokedEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.Revoked += x, x => _data.Revoked -= x); + } +} + +namespace Windows.ApplicationModel.ExtendedExecution.Foreground +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExtendedExecutionForegroundSessionEvents Events(this global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundSession item) => new RxExtendedExecutionForegroundSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExtendedExecutionForegroundSessionEvents + { + private readonly global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExtendedExecutionForegroundSessionEvents(global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Revoked => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundRevokedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundRevokedEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.Revoked += x, x => _data.Revoked -= x); + } +} + +namespace Windows.ApplicationModel.LockScreen +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLockApplicationHostEvents Events(this global::Windows.ApplicationModel.LockScreen.LockApplicationHost item) => new RxLockApplicationHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLockScreenInfoEvents Events(this global::Windows.ApplicationModel.LockScreen.LockScreenInfo item) => new RxLockScreenInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLockApplicationHostEvents + { + private readonly global::Windows.ApplicationModel.LockScreen.LockApplicationHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLockApplicationHostEvents(global::Windows.ApplicationModel.LockScreen.LockApplicationHost data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args)> Unlocking => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Unlocking += x, x => _data.Unlocking -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLockScreenInfoEvents + { + private readonly global::Windows.ApplicationModel.LockScreen.LockScreenInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLockScreenInfoEvents(global::Windows.ApplicationModel.LockScreen.LockScreenInfo data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> AlarmIconChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AlarmIconChanged += x, x => _data.AlarmIconChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> BadgesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BadgesChanged += x, x => _data.BadgesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> DetailTextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DetailTextChanged += x, x => _data.DetailTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> LockScreenImageChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LockScreenImageChanged += x, x => _data.LockScreenImageChanged -= x); + } +} + +namespace Windows.ApplicationModel.Preview.Notes +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotesWindowManagerPreviewEvents Events(this global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview item) => new RxNotesWindowManagerPreviewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotesWindowManagerPreviewEvents + { + private readonly global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotesWindowManagerPreviewEvents(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NotePlacementChangedPreviewEventArgs args)> NotePlacementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NotePlacementChangedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NotePlacementChangedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NotePlacementChanged += x, x => _data.NotePlacementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NoteVisibilityChangedPreviewEventArgs args)> NoteVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NoteVisibilityChangedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NoteVisibilityChangedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NoteVisibilityChanged += x, x => _data.NoteVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, object args)> SystemLockStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemLockStateChanged += x, x => _data.SystemLockStateChanged -= x); + } +} + +namespace Windows.ApplicationModel.Resources.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxResourceQualifierObservableMapEvents Events(this global::Windows.ApplicationModel.Resources.Core.ResourceQualifierObservableMap item) => new RxResourceQualifierObservableMapEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxResourceQualifierObservableMapEvents + { + private readonly global::Windows.ApplicationModel.Resources.Core.ResourceQualifierObservableMap _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxResourceQualifierObservableMapEvents(global::Windows.ApplicationModel.Resources.Core.ResourceQualifierObservableMap data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } +} + +namespace Windows.ApplicationModel.Search +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSearchPaneEvents Events(this global::Windows.ApplicationModel.Search.SearchPane item) => new RxSearchPaneEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSearchPaneEvents + { + private readonly global::Windows.ApplicationModel.Search.SearchPane _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSearchPaneEvents(global::Windows.ApplicationModel.Search.SearchPane data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQueryChangedEventArgs args)> QueryChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQueryChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQueryChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QueryChanged += x, x => _data.QueryChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQuerySubmittedEventArgs args)> QuerySubmitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQuerySubmittedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQuerySubmittedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneResultSuggestionChosenEventArgs args)> ResultSuggestionChosen => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneResultSuggestionChosenEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneResultSuggestionChosenEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneSuggestionsRequestedEventArgs args)> SuggestionsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneSuggestionsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneSuggestionsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneVisibilityChangedEventArgs args)> VisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneVisibilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneVisibilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + } +} + +namespace Windows.ApplicationModel.Search.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSearchSuggestionManagerEvents Events(this global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager item) => new RxSearchSuggestionManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSearchSuggestionManagerEvents + { + private readonly global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSearchSuggestionManagerEvents(global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.RequestingFocusOnKeyboardInputEventArgs args)> RequestingFocusOnKeyboardInput => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.RequestingFocusOnKeyboardInputEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.RequestingFocusOnKeyboardInputEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RequestingFocusOnKeyboardInput += x, x => _data.RequestingFocusOnKeyboardInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.SearchSuggestionsRequestedEventArgs args)> SuggestionsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.SearchSuggestionsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.SearchSuggestionsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); + } +} + +namespace Windows.ApplicationModel.Store +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLicenseInformationEvents Events(this global::Windows.ApplicationModel.Store.LicenseInformation item) => new RxLicenseInformationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLicenseInformationEvents + { + private readonly global::Windows.ApplicationModel.Store.LicenseInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLicenseInformationEvents(global::Windows.ApplicationModel.Store.LicenseInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LicenseChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler() => eventHandler(global::System.Reactive.Unit.Default); + return Handler; + }, x => _data.LicenseChanged += x, x => _data.LicenseChanged -= x); + } +} + +namespace Windows.ApplicationModel.Store.Preview.InstallControl +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppInstallItemEvents Events(this global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem item) => new RxAppInstallItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppInstallManagerEvents Events(this global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager item) => new RxAppInstallManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppInstallItemEvents + { + private readonly global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppInstallItemEvents(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppInstallManagerEvents + { + private readonly global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppInstallManagerEvents(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)> ItemCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemCompleted += x, x => _data.ItemCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)> ItemStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemStatusChanged += x, x => _data.ItemStatusChanged -= x); + } +} + +namespace Windows.ApplicationModel.UserActivities +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserActivityRequestManagerEvents Events(this global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager item) => new RxUserActivityRequestManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserActivityRequestManagerEvents + { + private readonly global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserActivityRequestManagerEvents(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args)> UserActivityRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserActivityRequested += x, x => _data.UserActivityRequested -= x); + } +} + +namespace Windows.ApplicationModel.UserDataAccounts +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserDataAccountStoreEvents Events(this global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore item) => new RxUserDataAccountStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserDataAccountStoreEvents + { + private readonly global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserDataAccountStoreEvents(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args)> StoreChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + } +} + +namespace Windows.ApplicationModel.UserDataTasks +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserDataTaskListSyncManagerEvents Events(this global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager item) => new RxUserDataTaskListSyncManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserDataTaskListSyncManagerEvents + { + private readonly global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserDataTaskListSyncManagerEvents(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + } +} + +namespace Windows.ApplicationModel.UserDataTasks.DataProvider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserDataTaskDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection item) => new RxUserDataTaskDataProviderConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserDataTaskDataProviderConnectionEvents + { + private readonly global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserDataTaskDataProviderConnectionEvents(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args)> CompleteTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CompleteTaskRequested += x, x => _data.CompleteTaskRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args)> CreateOrUpdateTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CreateOrUpdateTaskRequested += x, x => _data.CreateOrUpdateTaskRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args)> DeleteTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DeleteTaskRequested += x, x => _data.DeleteTaskRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args)> SkipOccurrenceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SkipOccurrenceRequested += x, x => _data.SkipOccurrenceRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args)> SyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + } +} + +namespace Windows.ApplicationModel.VoiceCommands +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVoiceCommandServiceConnectionEvents Events(this global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection item) => new RxVoiceCommandServiceConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVoiceCommandServiceConnectionEvents + { + private readonly global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVoiceCommandServiceConnectionEvents(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args)> VoiceCommandCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VoiceCommandCompleted += x, x => _data.VoiceCommandCompleted -= x); + } +} + +namespace Windows.ApplicationModel.Wallet.System +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWalletItemSystemStoreEvents Events(this global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore item) => new RxWalletItemSystemStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWalletItemSystemStoreEvents + { + private readonly global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWalletItemSystemStoreEvents(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args)> ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + } +} + +namespace Windows.Devices.AllJoyn +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAllJoynBusAttachmentEvents Events(this global::Windows.Devices.AllJoyn.AllJoynBusAttachment item) => new RxAllJoynBusAttachmentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAllJoynBusObjectEvents Events(this global::Windows.Devices.AllJoyn.AllJoynBusObject item) => new RxAllJoynBusObjectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAllJoynSessionEvents Events(this global::Windows.Devices.AllJoyn.AllJoynSession item) => new RxAllJoynSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAllJoynBusAttachmentEvents + { + private readonly global::Windows.Devices.AllJoyn.AllJoynBusAttachment _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAllJoynBusAttachmentEvents(global::Windows.Devices.AllJoyn.AllJoynBusAttachment data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args)> AcceptSessionJoinerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AcceptSessionJoinerRequested += x, x => _data.AcceptSessionJoinerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args)> AuthenticationComplete => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AuthenticationComplete += x, x => _data.AuthenticationComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args)> CredentialsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CredentialsRequested += x, x => _data.CredentialsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args)> CredentialsVerificationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CredentialsVerificationRequested += x, x => _data.CredentialsVerificationRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args)> SessionJoined => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionJoined += x, x => _data.SessionJoined -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAllJoynBusObjectEvents + { + private readonly global::Windows.Devices.AllJoyn.AllJoynBusObject _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAllJoynBusObjectEvents(global::Windows.Devices.AllJoyn.AllJoynBusObject data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAllJoynSessionEvents + { + private readonly global::Windows.Devices.AllJoyn.AllJoynSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAllJoynSessionEvents(global::Windows.Devices.AllJoyn.AllJoynSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args)> Lost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Lost += x, x => _data.Lost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args)> MemberAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MemberAdded += x, x => _data.MemberAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args)> MemberRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MemberRemoved += x, x => _data.MemberRemoved -= x); + } +} + +namespace Windows.Devices.Bluetooth +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBluetoothDeviceEvents Events(this global::Windows.Devices.Bluetooth.BluetoothDevice item) => new RxBluetoothDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBluetoothLEDeviceEvents Events(this global::Windows.Devices.Bluetooth.BluetoothLEDevice item) => new RxBluetoothLEDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBluetoothDeviceEvents + { + private readonly global::Windows.Devices.Bluetooth.BluetoothDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBluetoothDeviceEvents(global::Windows.Devices.Bluetooth.BluetoothDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)> ConnectionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)> NameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)> SdpRecordsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SdpRecordsChanged += x, x => _data.SdpRecordsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBluetoothLEDeviceEvents + { + private readonly global::Windows.Devices.Bluetooth.BluetoothLEDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBluetoothLEDeviceEvents(global::Windows.Devices.Bluetooth.BluetoothLEDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)> ConnectionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)> GattServicesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GattServicesChanged += x, x => _data.GattServicesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)> NameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); + } +} + +namespace Windows.Devices.Bluetooth.Advertisement +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBluetoothLEAdvertisementPublisherEvents Events(this global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher item) => new RxBluetoothLEAdvertisementPublisherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBluetoothLEAdvertisementWatcherEvents Events(this global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher item) => new RxBluetoothLEAdvertisementWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBluetoothLEAdvertisementPublisherEvents + { + private readonly global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBluetoothLEAdvertisementPublisherEvents(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBluetoothLEAdvertisementWatcherEvents + { + private readonly global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBluetoothLEAdvertisementWatcherEvents(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args)> Received => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Received += x, x => _data.Received -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } +} + +namespace Windows.Devices.Bluetooth.GenericAttributeProfile +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattCharacteristicEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic item) => new RxGattCharacteristicEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattLocalCharacteristicEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic item) => new RxGattLocalCharacteristicEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattLocalDescriptorEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor item) => new RxGattLocalDescriptorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattReadRequestEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest item) => new RxGattReadRequestEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattServiceProviderEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider item) => new RxGattServiceProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattSessionEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession item) => new RxGattSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattSubscribedClientEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient item) => new RxGattSubscribedClientEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattWriteRequestEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest item) => new RxGattWriteRequestEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattCharacteristicEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattCharacteristicEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args)> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattLocalCharacteristicEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattLocalCharacteristicEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)> ReadRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args)> SubscribedClientsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SubscribedClientsChanged += x, x => _data.SubscribedClientsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)> WriteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattLocalDescriptorEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattLocalDescriptorEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)> ReadRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)> WriteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattReadRequestEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattReadRequestEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattServiceProviderEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattServiceProviderEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args)> AdvertisementStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattSessionEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattSessionEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args)> MaxPduSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MaxPduSizeChanged += x, x => _data.MaxPduSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args)> SessionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattSubscribedClientEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattSubscribedClientEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args)> MaxNotificationSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MaxNotificationSizeChanged += x, x => _data.MaxNotificationSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattWriteRequestEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattWriteRequestEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace Windows.Devices.Display.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDisplayManagerEvents Events(this global::Windows.Devices.Display.Core.DisplayManager item) => new RxDisplayManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDisplayManagerEvents + { + private readonly global::Windows.Devices.Display.Core.DisplayManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDisplayManagerEvents(global::Windows.Devices.Display.Core.DisplayManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args)> Disabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Disabled += x, x => _data.Disabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args)> Enabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Enabled += x, x => _data.Enabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args)> PathsFailedOrInvalidated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PathsFailedOrInvalidated += x, x => _data.PathsFailedOrInvalidated -= x); + } +} + +namespace Windows.Devices.Enumeration +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDeviceAccessInformationEvents Events(this global::Windows.Devices.Enumeration.DeviceAccessInformation item) => new RxDeviceAccessInformationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDeviceInformationCustomPairingEvents Events(this global::Windows.Devices.Enumeration.DeviceInformationCustomPairing item) => new RxDeviceInformationCustomPairingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDevicePickerEvents Events(this global::Windows.Devices.Enumeration.DevicePicker item) => new RxDevicePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDeviceWatcherEvents Events(this global::Windows.Devices.Enumeration.DeviceWatcher item) => new RxDeviceWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDeviceAccessInformationEvents + { + private readonly global::Windows.Devices.Enumeration.DeviceAccessInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDeviceAccessInformationEvents(global::Windows.Devices.Enumeration.DeviceAccessInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args)> AccessChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessChanged += x, x => _data.AccessChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDeviceInformationCustomPairingEvents + { + private readonly global::Windows.Devices.Enumeration.DeviceInformationCustomPairing _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDeviceInformationCustomPairingEvents(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args)> PairingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PairingRequested += x, x => _data.PairingRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDevicePickerEvents + { + private readonly global::Windows.Devices.Enumeration.DevicePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDevicePickerEvents(global::Windows.Devices.Enumeration.DevicePicker data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DevicePicker sender, object args)> DevicePickerDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DevicePicker sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DevicePickerDismissed += x, x => _data.DevicePickerDismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args)> DeviceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DeviceSelected += x, x => _data.DeviceSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args)> DisconnectButtonClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDeviceWatcherEvents + { + private readonly global::Windows.Devices.Enumeration.DeviceWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDeviceWatcherEvents(global::Windows.Devices.Enumeration.DeviceWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace Windows.Devices.Enumeration.Pnp +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPnpObjectWatcherEvents Events(this global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher item) => new RxPnpObjectWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPnpObjectWatcherEvents + { + private readonly global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPnpObjectWatcherEvents(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace Windows.Devices.Geolocation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGeolocatorEvents Events(this global::Windows.Devices.Geolocation.Geolocator item) => new RxGeolocatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGeovisitMonitorEvents Events(this global::Windows.Devices.Geolocation.GeovisitMonitor item) => new RxGeovisitMonitorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGeolocatorEvents + { + private readonly global::Windows.Devices.Geolocation.Geolocator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGeolocatorEvents(global::Windows.Devices.Geolocation.Geolocator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args)> PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGeovisitMonitorEvents + { + private readonly global::Windows.Devices.Geolocation.GeovisitMonitor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGeovisitMonitorEvents(global::Windows.Devices.Geolocation.GeovisitMonitor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args)> VisitStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisitStateChanged += x, x => _data.VisitStateChanged -= x); + } +} + +namespace Windows.Devices.Geolocation.Geofencing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGeofenceMonitorEvents Events(this global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor item) => new RxGeofenceMonitorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGeofenceMonitorEvents + { + private readonly global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGeofenceMonitorEvents(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)> GeofenceStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GeofenceStateChanged += x, x => _data.GeofenceStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } +} + +namespace Windows.Devices.Gpio +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGpioPinEvents Events(this global::Windows.Devices.Gpio.GpioPin item) => new RxGpioPinEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGpioPinEvents + { + private readonly global::Windows.Devices.Gpio.GpioPin _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGpioPinEvents(global::Windows.Devices.Gpio.GpioPin data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Gpio.GpioPin sender, global::Windows.Devices.Gpio.GpioPinValueChangedEventArgs args)> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Gpio.GpioPin sender, global::Windows.Devices.Gpio.GpioPinValueChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Gpio.GpioPin sender, global::Windows.Devices.Gpio.GpioPinValueChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } +} + +namespace Windows.Devices.Gpio.Provider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIGpioPinProviderEvents Events(this global::Windows.Devices.Gpio.Provider.IGpioPinProvider item) => new RxIGpioPinProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIGpioPinProviderEvents + { + private readonly global::Windows.Devices.Gpio.Provider.IGpioPinProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIGpioPinProviderEvents(global::Windows.Devices.Gpio.Provider.IGpioPinProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Gpio.Provider.IGpioPinProvider sender, global::Windows.Devices.Gpio.Provider.GpioPinProviderValueChangedEventArgs args)> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Gpio.Provider.IGpioPinProvider sender, global::Windows.Devices.Gpio.Provider.GpioPinProviderValueChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Gpio.Provider.IGpioPinProvider sender, global::Windows.Devices.Gpio.Provider.GpioPinProviderValueChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } +} + +namespace Windows.Devices.HumanInterfaceDevice +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHidDeviceEvents Events(this global::Windows.Devices.HumanInterfaceDevice.HidDevice item) => new RxHidDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHidDeviceEvents + { + private readonly global::Windows.Devices.HumanInterfaceDevice.HidDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHidDeviceEvents(global::Windows.Devices.HumanInterfaceDevice.HidDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args)> InputReportReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InputReportReceived += x, x => _data.InputReportReceived -= x); + } +} + +namespace Windows.Devices.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMouseDeviceEvents Events(this global::Windows.Devices.Input.MouseDevice item) => new RxMouseDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPenButtonListenerEvents Events(this global::Windows.Devices.Input.PenButtonListener item) => new RxPenButtonListenerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPenDockListenerEvents Events(this global::Windows.Devices.Input.PenDockListener item) => new RxPenDockListenerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMouseDeviceEvents + { + private readonly global::Windows.Devices.Input.MouseDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMouseDeviceEvents(global::Windows.Devices.Input.MouseDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args)> MouseMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MouseMoved += x, x => _data.MouseMoved -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPenButtonListenerEvents + { + private readonly global::Windows.Devices.Input.PenButtonListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPenButtonListenerEvents(global::Windows.Devices.Input.PenButtonListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenButtonListener sender, object args)> IsSupportedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenButtonListener sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenButtonListener sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonClickedEventArgs args)> TailButtonClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonClickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonClickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TailButtonClicked += x, x => _data.TailButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonDoubleClickedEventArgs args)> TailButtonDoubleClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonDoubleClickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonDoubleClickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TailButtonDoubleClicked += x, x => _data.TailButtonDoubleClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonLongPressedEventArgs args)> TailButtonLongPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonLongPressedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonLongPressedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TailButtonLongPressed += x, x => _data.TailButtonLongPressed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPenDockListenerEvents + { + private readonly global::Windows.Devices.Input.PenDockListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPenDockListenerEvents(global::Windows.Devices.Input.PenDockListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenDockedEventArgs args)> Docked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenDockedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenDockedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Docked += x, x => _data.Docked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenDockListener sender, object args)> IsSupportedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenDockListener sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenDockListener sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenUndockedEventArgs args)> Undocked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenUndockedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenUndockedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Undocked += x, x => _data.Undocked -= x); + } +} + +namespace Windows.Devices.Input.Preview +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGazeDeviceWatcherPreviewEvents Events(this global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview item) => new RxGazeDeviceWatcherPreviewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGazeInputSourcePreviewEvents Events(this global::Windows.Devices.Input.Preview.GazeInputSourcePreview item) => new RxGazeInputSourcePreviewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGazeDeviceWatcherPreviewEvents + { + private readonly global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGazeDeviceWatcherPreviewEvents(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGazeInputSourcePreviewEvents + { + private readonly global::Windows.Devices.Input.Preview.GazeInputSourcePreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGazeInputSourcePreviewEvents(global::Windows.Devices.Input.Preview.GazeInputSourcePreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args)> GazeEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GazeEntered += x, x => _data.GazeEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args)> GazeExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GazeExited += x, x => _data.GazeExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args)> GazeMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GazeMoved += x, x => _data.GazeMoved -= x); + } +} + +namespace Windows.Devices.Lights +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLampEvents Events(this global::Windows.Devices.Lights.Lamp item) => new RxLampEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLampEvents + { + private readonly global::Windows.Devices.Lights.Lamp _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLampEvents(global::Windows.Devices.Lights.Lamp data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args)> AvailabilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); + } +} + +namespace Windows.Devices.Lights.Effects +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLampArrayBitmapEffectEvents Events(this global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect item) => new RxLampArrayBitmapEffectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLampArrayCustomEffectEvents Events(this global::Windows.Devices.Lights.Effects.LampArrayCustomEffect item) => new RxLampArrayCustomEffectEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLampArrayBitmapEffectEvents + { + private readonly global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLampArrayBitmapEffectEvents(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args)> BitmapRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLampArrayCustomEffectEvents + { + private readonly global::Windows.Devices.Lights.Effects.LampArrayCustomEffect _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLampArrayCustomEffectEvents(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args)> UpdateRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UpdateRequested += x, x => _data.UpdateRequested -= x); + } +} + +namespace Windows.Devices.Midi +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMidiInPortEvents Events(this global::Windows.Devices.Midi.MidiInPort item) => new RxMidiInPortEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMidiInPortEvents + { + private readonly global::Windows.Devices.Midi.MidiInPort _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMidiInPortEvents(global::Windows.Devices.Midi.MidiInPort data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } +} + +namespace Windows.Devices.Perception +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionColorFrameReaderEvents Events(this global::Windows.Devices.Perception.PerceptionColorFrameReader item) => new RxPerceptionColorFrameReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionColorFrameSourceEvents Events(this global::Windows.Devices.Perception.PerceptionColorFrameSource item) => new RxPerceptionColorFrameSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionColorFrameSourceWatcherEvents Events(this global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher item) => new RxPerceptionColorFrameSourceWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionControlSessionEvents Events(this global::Windows.Devices.Perception.PerceptionControlSession item) => new RxPerceptionControlSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionDepthFrameReaderEvents Events(this global::Windows.Devices.Perception.PerceptionDepthFrameReader item) => new RxPerceptionDepthFrameReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionDepthFrameSourceEvents Events(this global::Windows.Devices.Perception.PerceptionDepthFrameSource item) => new RxPerceptionDepthFrameSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionDepthFrameSourceWatcherEvents Events(this global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher item) => new RxPerceptionDepthFrameSourceWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionInfraredFrameReaderEvents Events(this global::Windows.Devices.Perception.PerceptionInfraredFrameReader item) => new RxPerceptionInfraredFrameReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionInfraredFrameSourceEvents Events(this global::Windows.Devices.Perception.PerceptionInfraredFrameSource item) => new RxPerceptionInfraredFrameSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionInfraredFrameSourceWatcherEvents Events(this global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher item) => new RxPerceptionInfraredFrameSourceWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionColorFrameReaderEvents + { + private readonly global::Windows.Devices.Perception.PerceptionColorFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionColorFrameReaderEvents(global::Windows.Devices.Perception.PerceptionColorFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionColorFrameSourceEvents + { + private readonly global::Windows.Devices.Perception.PerceptionColorFrameSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionColorFrameSourceEvents(global::Windows.Devices.Perception.PerceptionColorFrameSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> ActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> CameraIntrinsicsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)> PropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> VideoProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionColorFrameSourceWatcherEvents + { + private readonly global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionColorFrameSourceWatcherEvents(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args)> SourceAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args)> SourceRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionControlSessionEvents + { + private readonly global::Windows.Devices.Perception.PerceptionControlSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionControlSessionEvents(global::Windows.Devices.Perception.PerceptionControlSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionControlSession sender, object args)> ControlLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionControlSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionControlSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionDepthFrameReaderEvents + { + private readonly global::Windows.Devices.Perception.PerceptionDepthFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionDepthFrameReaderEvents(global::Windows.Devices.Perception.PerceptionDepthFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionDepthFrameSourceEvents + { + private readonly global::Windows.Devices.Perception.PerceptionDepthFrameSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionDepthFrameSourceEvents(global::Windows.Devices.Perception.PerceptionDepthFrameSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> ActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> CameraIntrinsicsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)> PropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> VideoProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionDepthFrameSourceWatcherEvents + { + private readonly global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionDepthFrameSourceWatcherEvents(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args)> SourceAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args)> SourceRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionInfraredFrameReaderEvents + { + private readonly global::Windows.Devices.Perception.PerceptionInfraredFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionInfraredFrameReaderEvents(global::Windows.Devices.Perception.PerceptionInfraredFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionInfraredFrameSourceEvents + { + private readonly global::Windows.Devices.Perception.PerceptionInfraredFrameSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionInfraredFrameSourceEvents(global::Windows.Devices.Perception.PerceptionInfraredFrameSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> ActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> CameraIntrinsicsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)> PropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> VideoProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionInfraredFrameSourceWatcherEvents + { + private readonly global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionInfraredFrameSourceWatcherEvents(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args)> SourceAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args)> SourceRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } +} + +namespace Windows.Devices.PointOfService +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBarcodeScannerEvents Events(this global::Windows.Devices.PointOfService.BarcodeScanner item) => new RxBarcodeScannerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCashDrawerEvents Events(this global::Windows.Devices.PointOfService.CashDrawer item) => new RxCashDrawerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCashDrawerCloseAlarmEvents Events(this global::Windows.Devices.PointOfService.CashDrawerCloseAlarm item) => new RxCashDrawerCloseAlarmEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCashDrawerEventSourceEvents Events(this global::Windows.Devices.PointOfService.CashDrawerEventSource item) => new RxCashDrawerEventSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClaimedBarcodeScannerEvents Events(this global::Windows.Devices.PointOfService.ClaimedBarcodeScanner item) => new RxClaimedBarcodeScannerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClaimedCashDrawerEvents Events(this global::Windows.Devices.PointOfService.ClaimedCashDrawer item) => new RxClaimedCashDrawerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClaimedLineDisplayEvents Events(this global::Windows.Devices.PointOfService.ClaimedLineDisplay item) => new RxClaimedLineDisplayEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClaimedMagneticStripeReaderEvents Events(this global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader item) => new RxClaimedMagneticStripeReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClaimedPosPrinterEvents Events(this global::Windows.Devices.PointOfService.ClaimedPosPrinter item) => new RxClaimedPosPrinterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMagneticStripeReaderEvents Events(this global::Windows.Devices.PointOfService.MagneticStripeReader item) => new RxMagneticStripeReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPosPrinterEvents Events(this global::Windows.Devices.PointOfService.PosPrinter item) => new RxPosPrinterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBarcodeScannerEvents + { + private readonly global::Windows.Devices.PointOfService.BarcodeScanner _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBarcodeScannerEvents(global::Windows.Devices.PointOfService.BarcodeScanner data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCashDrawerEvents + { + private readonly global::Windows.Devices.PointOfService.CashDrawer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCashDrawerEvents(global::Windows.Devices.PointOfService.CashDrawer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCashDrawerCloseAlarmEvents + { + private readonly global::Windows.Devices.PointOfService.CashDrawerCloseAlarm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCashDrawerCloseAlarmEvents(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args)> AlarmTimeoutExpired => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AlarmTimeoutExpired += x, x => _data.AlarmTimeoutExpired -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCashDrawerEventSourceEvents + { + private readonly global::Windows.Devices.PointOfService.CashDrawerEventSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCashDrawerEventSourceEvents(global::Windows.Devices.PointOfService.CashDrawerEventSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args)> DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args)> DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClaimedBarcodeScannerEvents + { + private readonly global::Windows.Devices.PointOfService.ClaimedBarcodeScanner _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClaimedBarcodeScannerEvents(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args)> DataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args)> ImagePreviewReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ImagePreviewReceived += x, x => _data.ImagePreviewReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner>(eventHandler => + { + void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); + return Handler; + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TriggerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner>(eventHandler => + { + void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); + return Handler; + }, x => _data.TriggerPressed += x, x => _data.TriggerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TriggerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner>(eventHandler => + { + void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); + return Handler; + }, x => _data.TriggerReleased += x, x => _data.TriggerReleased -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClaimedCashDrawerEvents + { + private readonly global::Windows.Devices.PointOfService.ClaimedCashDrawer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClaimedCashDrawerEvents(global::Windows.Devices.PointOfService.ClaimedCashDrawer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args)> ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClaimedLineDisplayEvents + { + private readonly global::Windows.Devices.PointOfService.ClaimedLineDisplay _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClaimedLineDisplayEvents(global::Windows.Devices.PointOfService.ClaimedLineDisplay data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args)> ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClaimedMagneticStripeReaderEvents + { + private readonly global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClaimedMagneticStripeReaderEvents(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args)> AamvaCardDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AamvaCardDataReceived += x, x => _data.AamvaCardDataReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args)> BankCardDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BankCardDataReceived += x, x => _data.BankCardDataReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader>(eventHandler => + { + void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader e) => eventHandler(e); + return Handler; + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args)> VendorSpecificDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VendorSpecificDataReceived += x, x => _data.VendorSpecificDataReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClaimedPosPrinterEvents + { + private readonly global::Windows.Devices.PointOfService.ClaimedPosPrinter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClaimedPosPrinterEvents(global::Windows.Devices.PointOfService.ClaimedPosPrinter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args)> ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMagneticStripeReaderEvents + { + private readonly global::Windows.Devices.PointOfService.MagneticStripeReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMagneticStripeReaderEvents(global::Windows.Devices.PointOfService.MagneticStripeReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPosPrinterEvents + { + private readonly global::Windows.Devices.PointOfService.PosPrinter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPosPrinterEvents(global::Windows.Devices.PointOfService.PosPrinter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + } +} + +namespace Windows.Devices.PointOfService.Provider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBarcodeScannerFrameReaderEvents Events(this global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader item) => new RxBarcodeScannerFrameReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBarcodeScannerProviderConnectionEvents Events(this global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection item) => new RxBarcodeScannerProviderConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBarcodeScannerFrameReaderEvents + { + private readonly global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBarcodeScannerFrameReaderEvents(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBarcodeScannerProviderConnectionEvents + { + private readonly global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBarcodeScannerProviderConnectionEvents(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args)> DisableScannerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisableScannerRequested += x, x => _data.DisableScannerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args)> EnableScannerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnableScannerRequested += x, x => _data.EnableScannerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args)> GetBarcodeSymbologyAttributesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GetBarcodeSymbologyAttributesRequested += x, x => _data.GetBarcodeSymbologyAttributesRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args)> HideVideoPreviewRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HideVideoPreviewRequested += x, x => _data.HideVideoPreviewRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args)> SetActiveSymbologiesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SetActiveSymbologiesRequested += x, x => _data.SetActiveSymbologiesRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args)> SetBarcodeSymbologyAttributesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SetBarcodeSymbologyAttributesRequested += x, x => _data.SetBarcodeSymbologyAttributesRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args)> StartSoftwareTriggerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StartSoftwareTriggerRequested += x, x => _data.StartSoftwareTriggerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args)> StopSoftwareTriggerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StopSoftwareTriggerRequested += x, x => _data.StopSoftwareTriggerRequested -= x); + } +} + +namespace Windows.Devices.Power +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBatteryEvents Events(this global::Windows.Devices.Power.Battery item) => new RxBatteryEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBatteryEvents + { + private readonly global::Windows.Devices.Power.Battery _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBatteryEvents(global::Windows.Devices.Power.Battery data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Power.Battery sender, object args)> ReportUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Power.Battery sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Power.Battery sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReportUpdated += x, x => _data.ReportUpdated -= x); + } +} + +namespace Windows.Devices.Printers.Extensions +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrint3DWorkflowEvents Events(this global::Windows.Devices.Printers.Extensions.Print3DWorkflow item) => new RxPrint3DWorkflowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintTaskConfigurationEvents Events(this global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration item) => new RxPrintTaskConfigurationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrint3DWorkflowEvents + { + private readonly global::Windows.Devices.Printers.Extensions.Print3DWorkflow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrint3DWorkflowEvents(global::Windows.Devices.Printers.Extensions.Print3DWorkflow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args)> PrinterChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrinterChanged += x, x => _data.PrinterChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args)> PrintRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrintRequested += x, x => _data.PrintRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintTaskConfigurationEvents + { + private readonly global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintTaskConfigurationEvents(global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration sender, global::Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequestedEventArgs args)> SaveRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration sender, global::Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration sender, global::Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SaveRequested += x, x => _data.SaveRequested -= x); + } +} + +namespace Windows.Devices.Radios +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioEvents Events(this global::Windows.Devices.Radios.Radio item) => new RxRadioEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioEvents + { + private readonly global::Windows.Devices.Radios.Radio _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioEvents(global::Windows.Devices.Radios.Radio data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Radios.Radio sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Radios.Radio sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Radios.Radio sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace Windows.Devices.Sensors +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAccelerometerEvents Events(this global::Windows.Devices.Sensors.Accelerometer item) => new RxAccelerometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxActivitySensorEvents Events(this global::Windows.Devices.Sensors.ActivitySensor item) => new RxActivitySensorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAltimeterEvents Events(this global::Windows.Devices.Sensors.Altimeter item) => new RxAltimeterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBarometerEvents Events(this global::Windows.Devices.Sensors.Barometer item) => new RxBarometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompassEvents Events(this global::Windows.Devices.Sensors.Compass item) => new RxCompassEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGyrometerEvents Events(this global::Windows.Devices.Sensors.Gyrometer item) => new RxGyrometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHingeAngleSensorEvents Events(this global::Windows.Devices.Sensors.HingeAngleSensor item) => new RxHingeAngleSensorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInclinometerEvents Events(this global::Windows.Devices.Sensors.Inclinometer item) => new RxInclinometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLightSensorEvents Events(this global::Windows.Devices.Sensors.LightSensor item) => new RxLightSensorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMagnetometerEvents Events(this global::Windows.Devices.Sensors.Magnetometer item) => new RxMagnetometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxOrientationSensorEvents Events(this global::Windows.Devices.Sensors.OrientationSensor item) => new RxOrientationSensorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPedometerEvents Events(this global::Windows.Devices.Sensors.Pedometer item) => new RxPedometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProximitySensorEvents Events(this global::Windows.Devices.Sensors.ProximitySensor item) => new RxProximitySensorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSimpleOrientationSensorEvents Events(this global::Windows.Devices.Sensors.SimpleOrientationSensor item) => new RxSimpleOrientationSensorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAccelerometerEvents + { + private readonly global::Windows.Devices.Sensors.Accelerometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAccelerometerEvents(global::Windows.Devices.Sensors.Accelerometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args)> Shaken => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Shaken += x, x => _data.Shaken -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxActivitySensorEvents + { + private readonly global::Windows.Devices.Sensors.ActivitySensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxActivitySensorEvents(global::Windows.Devices.Sensors.ActivitySensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAltimeterEvents + { + private readonly global::Windows.Devices.Sensors.Altimeter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAltimeterEvents(global::Windows.Devices.Sensors.Altimeter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBarometerEvents + { + private readonly global::Windows.Devices.Sensors.Barometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBarometerEvents(global::Windows.Devices.Sensors.Barometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompassEvents + { + private readonly global::Windows.Devices.Sensors.Compass _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompassEvents(global::Windows.Devices.Sensors.Compass data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGyrometerEvents + { + private readonly global::Windows.Devices.Sensors.Gyrometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGyrometerEvents(global::Windows.Devices.Sensors.Gyrometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHingeAngleSensorEvents + { + private readonly global::Windows.Devices.Sensors.HingeAngleSensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHingeAngleSensorEvents(global::Windows.Devices.Sensors.HingeAngleSensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInclinometerEvents + { + private readonly global::Windows.Devices.Sensors.Inclinometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInclinometerEvents(global::Windows.Devices.Sensors.Inclinometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLightSensorEvents + { + private readonly global::Windows.Devices.Sensors.LightSensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLightSensorEvents(global::Windows.Devices.Sensors.LightSensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMagnetometerEvents + { + private readonly global::Windows.Devices.Sensors.Magnetometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMagnetometerEvents(global::Windows.Devices.Sensors.Magnetometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxOrientationSensorEvents + { + private readonly global::Windows.Devices.Sensors.OrientationSensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxOrientationSensorEvents(global::Windows.Devices.Sensors.OrientationSensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPedometerEvents + { + private readonly global::Windows.Devices.Sensors.Pedometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPedometerEvents(global::Windows.Devices.Sensors.Pedometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProximitySensorEvents + { + private readonly global::Windows.Devices.Sensors.ProximitySensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProximitySensorEvents(global::Windows.Devices.Sensors.ProximitySensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSimpleOrientationSensorEvents + { + private readonly global::Windows.Devices.Sensors.SimpleOrientationSensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSimpleOrientationSensorEvents(global::Windows.Devices.Sensors.SimpleOrientationSensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args)> OrientationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + } +} + +namespace Windows.Devices.Sensors.Custom +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCustomSensorEvents Events(this global::Windows.Devices.Sensors.Custom.CustomSensor item) => new RxCustomSensorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCustomSensorEvents + { + private readonly global::Windows.Devices.Sensors.Custom.CustomSensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCustomSensorEvents(global::Windows.Devices.Sensors.Custom.CustomSensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } +} + +namespace Windows.Devices.SerialCommunication +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerialDeviceEvents Events(this global::Windows.Devices.SerialCommunication.SerialDevice item) => new RxSerialDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerialDeviceEvents + { + private readonly global::Windows.Devices.SerialCommunication.SerialDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerialDeviceEvents(global::Windows.Devices.SerialCommunication.SerialDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args)> ErrorReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorReceived += x, x => _data.ErrorReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args)> PinChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PinChanged += x, x => _data.PinChanged -= x); + } +} + +namespace Windows.Devices.SmartCards +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSmartCardEmulatorEvents Events(this global::Windows.Devices.SmartCards.SmartCardEmulator item) => new RxSmartCardEmulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSmartCardReaderEvents Events(this global::Windows.Devices.SmartCards.SmartCardReader item) => new RxSmartCardReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSmartCardEmulatorEvents + { + private readonly global::Windows.Devices.SmartCards.SmartCardEmulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSmartCardEmulatorEvents(global::Windows.Devices.SmartCards.SmartCardEmulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorApduReceivedEventArgs args)> ApduReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorApduReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorApduReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ApduReceived += x, x => _data.ApduReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorConnectionDeactivatedEventArgs args)> ConnectionDeactivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorConnectionDeactivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorConnectionDeactivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionDeactivated += x, x => _data.ConnectionDeactivated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSmartCardReaderEvents + { + private readonly global::Windows.Devices.SmartCards.SmartCardReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSmartCardReaderEvents(global::Windows.Devices.SmartCards.SmartCardReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args)> CardAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CardAdded += x, x => _data.CardAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args)> CardRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CardRemoved += x, x => _data.CardRemoved -= x); + } +} + +namespace Windows.Devices.Sms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxISmsDeviceEvents Events(this global::Windows.Devices.Sms.ISmsDevice item) => new RxISmsDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSmsDeviceEvents Events(this global::Windows.Devices.Sms.SmsDevice item) => new RxSmsDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSmsDevice2Events Events(this global::Windows.Devices.Sms.SmsDevice2 item) => new RxSmsDevice2Events(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSmsMessageRegistrationEvents Events(this global::Windows.Devices.Sms.SmsMessageRegistration item) => new RxSmsMessageRegistrationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxISmsDeviceEvents + { + private readonly global::Windows.Devices.Sms.ISmsDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxISmsDeviceEvents(global::Windows.Devices.Sms.ISmsDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SmsDeviceStatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsDevice sender) => eventHandler(sender); + return Handler; + }, x => _data.SmsDeviceStatusChanged += x, x => _data.SmsDeviceStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sms.SmsDevice sender, global::Windows.Devices.Sms.SmsMessageReceivedEventArgs e)> SmsMessageReceived => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsDevice sender, global::Windows.Devices.Sms.SmsMessageReceivedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.SmsMessageReceived += x, x => _data.SmsMessageReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSmsDeviceEvents + { + private readonly global::Windows.Devices.Sms.SmsDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSmsDeviceEvents(global::Windows.Devices.Sms.SmsDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SmsDeviceStatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsDevice sender) => eventHandler(sender); + return Handler; + }, x => _data.SmsDeviceStatusChanged += x, x => _data.SmsDeviceStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sms.SmsDevice sender, global::Windows.Devices.Sms.SmsMessageReceivedEventArgs e)> SmsMessageReceived => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsDevice sender, global::Windows.Devices.Sms.SmsMessageReceivedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.SmsMessageReceived += x, x => _data.SmsMessageReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSmsDevice2Events + { + private readonly global::Windows.Devices.Sms.SmsDevice2 _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSmsDevice2Events(global::Windows.Devices.Sms.SmsDevice2 data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sms.SmsDevice2 sender, object args)> DeviceStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sms.SmsDevice2 sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsDevice2 sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DeviceStatusChanged += x, x => _data.DeviceStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSmsMessageRegistrationEvents + { + private readonly global::Windows.Devices.Sms.SmsMessageRegistration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSmsMessageRegistrationEvents(global::Windows.Devices.Sms.SmsMessageRegistration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } +} + +namespace Windows.Devices.Usb +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUsbInterruptInPipeEvents Events(this global::Windows.Devices.Usb.UsbInterruptInPipe item) => new RxUsbInterruptInPipeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUsbInterruptInPipeEvents + { + private readonly global::Windows.Devices.Usb.UsbInterruptInPipe _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUsbInterruptInPipeEvents(global::Windows.Devices.Usb.UsbInterruptInPipe data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args)> DataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); + } +} + +namespace Windows.Devices.WiFi +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiAdapterEvents Events(this global::Windows.Devices.WiFi.WiFiAdapter item) => new RxWiFiAdapterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiAdapterEvents + { + private readonly global::Windows.Devices.WiFi.WiFiAdapter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiAdapterEvents(global::Windows.Devices.WiFi.WiFiAdapter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFi.WiFiAdapter sender, object args)> AvailableNetworksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFi.WiFiAdapter sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFi.WiFiAdapter sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailableNetworksChanged += x, x => _data.AvailableNetworksChanged -= x); + } +} + +namespace Windows.Devices.WiFiDirect +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectAdvertisementPublisherEvents Events(this global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher item) => new RxWiFiDirectAdvertisementPublisherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectConnectionListenerEvents Events(this global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener item) => new RxWiFiDirectConnectionListenerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectDeviceEvents Events(this global::Windows.Devices.WiFiDirect.WiFiDirectDevice item) => new RxWiFiDirectDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectAdvertisementPublisherEvents + { + private readonly global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectAdvertisementPublisherEvents(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectConnectionListenerEvents + { + private readonly global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectConnectionListenerEvents(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args)> ConnectionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectDeviceEvents + { + private readonly global::Windows.Devices.WiFiDirect.WiFiDirectDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectDeviceEvents(global::Windows.Devices.WiFiDirect.WiFiDirectDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args)> ConnectionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + } +} + +namespace Windows.Devices.WiFiDirect.Services +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectServiceEvents Events(this global::Windows.Devices.WiFiDirect.Services.WiFiDirectService item) => new RxWiFiDirectServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectServiceAdvertiserEvents Events(this global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser item) => new RxWiFiDirectServiceAdvertiserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectServiceSessionEvents Events(this global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession item) => new RxWiFiDirectServiceSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectServiceEvents + { + private readonly global::Windows.Devices.WiFiDirect.Services.WiFiDirectService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectServiceEvents(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args)> SessionDeferred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionDeferred += x, x => _data.SessionDeferred -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectServiceAdvertiserEvents + { + private readonly global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectServiceAdvertiserEvents(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args)> AdvertisementStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args)> AutoAcceptSessionConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutoAcceptSessionConnected += x, x => _data.AutoAcceptSessionConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args)> SessionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionRequested += x, x => _data.SessionRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectServiceSessionEvents + { + private readonly global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectServiceSessionEvents(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args)> RemotePortAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RemotePortAdded += x, x => _data.RemotePortAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args)> SessionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + } +} + +namespace Windows.Foundation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIMemoryBufferReferenceEvents Events(this global::Windows.Foundation.IMemoryBufferReference item) => new RxIMemoryBufferReferenceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIMemoryBufferReferenceEvents + { + private readonly global::Windows.Foundation.IMemoryBufferReference _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIMemoryBufferReferenceEvents(global::Windows.Foundation.IMemoryBufferReference data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.IMemoryBufferReference sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.IMemoryBufferReference sender, object args)>(eventHandler => + { + void Handler(global::Windows.Foundation.IMemoryBufferReference sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + } +} + +namespace Windows.Foundation.Collections +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertySetEvents Events(this global::Windows.Foundation.Collections.PropertySet item) => new RxPropertySetEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStringMapEvents Events(this global::Windows.Foundation.Collections.StringMap item) => new RxStringMapEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxValueSetEvents Events(this global::Windows.Foundation.Collections.ValueSet item) => new RxValueSetEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertySetEvents + { + private readonly global::Windows.Foundation.Collections.PropertySet _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertySetEvents(global::Windows.Foundation.Collections.PropertySet data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStringMapEvents + { + private readonly global::Windows.Foundation.Collections.StringMap _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStringMapEvents(global::Windows.Foundation.Collections.StringMap data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxValueSetEvents + { + private readonly global::Windows.Foundation.Collections.ValueSet _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxValueSetEvents(global::Windows.Foundation.Collections.ValueSet data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } +} + +namespace Windows.Foundation.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileLoggingSessionEvents Events(this global::Windows.Foundation.Diagnostics.FileLoggingSession item) => new RxFileLoggingSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIFileLoggingSessionEvents Events(this global::Windows.Foundation.Diagnostics.IFileLoggingSession item) => new RxIFileLoggingSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxILoggingChannelEvents Events(this global::Windows.Foundation.Diagnostics.ILoggingChannel item) => new RxILoggingChannelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLoggingChannelEvents Events(this global::Windows.Foundation.Diagnostics.LoggingChannel item) => new RxLoggingChannelEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileLoggingSessionEvents + { + private readonly global::Windows.Foundation.Diagnostics.FileLoggingSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileLoggingSessionEvents(global::Windows.Foundation.Diagnostics.FileLoggingSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)> LogFileGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIFileLoggingSessionEvents + { + private readonly global::Windows.Foundation.Diagnostics.IFileLoggingSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIFileLoggingSessionEvents(global::Windows.Foundation.Diagnostics.IFileLoggingSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)> LogFileGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxILoggingChannelEvents + { + private readonly global::Windows.Foundation.Diagnostics.ILoggingChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxILoggingChannelEvents(global::Windows.Foundation.Diagnostics.ILoggingChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)> LoggingEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)>(eventHandler => + { + void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLoggingChannelEvents + { + private readonly global::Windows.Foundation.Diagnostics.LoggingChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLoggingChannelEvents(global::Windows.Foundation.Diagnostics.LoggingChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)> LoggingEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)>(eventHandler => + { + void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + } +} + +namespace Windows.Gaming.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxArcadeStickEvents Events(this global::Windows.Gaming.Input.ArcadeStick item) => new RxArcadeStickEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFlightStickEvents Events(this global::Windows.Gaming.Input.FlightStick item) => new RxFlightStickEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGamepadEvents Events(this global::Windows.Gaming.Input.Gamepad item) => new RxGamepadEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIGameControllerEvents Events(this global::Windows.Gaming.Input.IGameController item) => new RxIGameControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRacingWheelEvents Events(this global::Windows.Gaming.Input.RacingWheel item) => new RxRacingWheelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRawGameControllerEvents Events(this global::Windows.Gaming.Input.RawGameController item) => new RxRawGameControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUINavigationControllerEvents Events(this global::Windows.Gaming.Input.UINavigationController item) => new RxUINavigationControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxArcadeStickEvents + { + private readonly global::Windows.Gaming.Input.ArcadeStick _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxArcadeStickEvents(global::Windows.Gaming.Input.ArcadeStick data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFlightStickEvents + { + private readonly global::Windows.Gaming.Input.FlightStick _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFlightStickEvents(global::Windows.Gaming.Input.FlightStick data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGamepadEvents + { + private readonly global::Windows.Gaming.Input.Gamepad _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGamepadEvents(global::Windows.Gaming.Input.Gamepad data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIGameControllerEvents + { + private readonly global::Windows.Gaming.Input.IGameController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIGameControllerEvents(global::Windows.Gaming.Input.IGameController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRacingWheelEvents + { + private readonly global::Windows.Gaming.Input.RacingWheel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRacingWheelEvents(global::Windows.Gaming.Input.RacingWheel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRawGameControllerEvents + { + private readonly global::Windows.Gaming.Input.RawGameController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRawGameControllerEvents(global::Windows.Gaming.Input.RawGameController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUINavigationControllerEvents + { + private readonly global::Windows.Gaming.Input.UINavigationController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUINavigationControllerEvents(global::Windows.Gaming.Input.UINavigationController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } +} + +namespace Windows.Gaming.UI +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGameChatOverlayMessageSourceEvents Events(this global::Windows.Gaming.UI.GameChatOverlayMessageSource item) => new RxGameChatOverlayMessageSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGameChatOverlayMessageSourceEvents + { + private readonly global::Windows.Gaming.UI.GameChatOverlayMessageSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGameChatOverlayMessageSourceEvents(global::Windows.Gaming.UI.GameChatOverlayMessageSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.UI.GameChatOverlayMessageSource sender, global::Windows.Gaming.UI.GameChatMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.UI.GameChatOverlayMessageSource sender, global::Windows.Gaming.UI.GameChatMessageReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.UI.GameChatOverlayMessageSource sender, global::Windows.Gaming.UI.GameChatMessageReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } +} + +namespace Windows.Graphics.Capture +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDirect3D11CaptureFramePoolEvents Events(this global::Windows.Graphics.Capture.Direct3D11CaptureFramePool item) => new RxDirect3D11CaptureFramePoolEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGraphicsCaptureItemEvents Events(this global::Windows.Graphics.Capture.GraphicsCaptureItem item) => new RxGraphicsCaptureItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDirect3D11CaptureFramePoolEvents + { + private readonly global::Windows.Graphics.Capture.Direct3D11CaptureFramePool _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDirect3D11CaptureFramePoolEvents(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGraphicsCaptureItemEvents + { + private readonly global::Windows.Graphics.Capture.GraphicsCaptureItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGraphicsCaptureItemEvents(global::Windows.Graphics.Capture.GraphicsCaptureItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + } +} + +namespace Windows.Graphics.Display +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBrightnessOverrideEvents Events(this global::Windows.Graphics.Display.BrightnessOverride item) => new RxBrightnessOverrideEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDisplayEnhancementOverrideEvents Events(this global::Windows.Graphics.Display.DisplayEnhancementOverride item) => new RxDisplayEnhancementOverrideEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDisplayInformationEvents Events(this global::Windows.Graphics.Display.DisplayInformation item) => new RxDisplayInformationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBrightnessOverrideEvents + { + private readonly global::Windows.Graphics.Display.BrightnessOverride _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBrightnessOverrideEvents(global::Windows.Graphics.Display.BrightnessOverride data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.BrightnessOverride sender, object args)> BrightnessLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.BrightnessOverride sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BrightnessLevelChanged += x, x => _data.BrightnessLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.BrightnessOverride sender, object args)> IsOverrideActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.BrightnessOverride sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.BrightnessOverride sender, object args)> IsSupportedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.BrightnessOverride sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDisplayEnhancementOverrideEvents + { + private readonly global::Windows.Graphics.Display.DisplayEnhancementOverride _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDisplayEnhancementOverrideEvents(global::Windows.Graphics.Display.DisplayEnhancementOverride data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)> CanOverrideChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CanOverrideChanged += x, x => _data.CanOverrideChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args)> DisplayEnhancementOverrideCapabilitiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisplayEnhancementOverrideCapabilitiesChanged += x, x => _data.DisplayEnhancementOverrideCapabilitiesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)> IsOverrideActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDisplayInformationEvents + { + private readonly global::Windows.Graphics.Display.DisplayInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDisplayInformationEvents(global::Windows.Graphics.Display.DisplayInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> AdvancedColorInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AdvancedColorInfoChanged += x, x => _data.AdvancedColorInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> ColorProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ColorProfileChanged += x, x => _data.ColorProfileChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> DpiChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> OrientationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> StereoEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StereoEnabledChanged += x, x => _data.StereoEnabledChanged -= x); + } +} + +namespace Windows.Graphics.Display.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHdmiDisplayInformationEvents Events(this global::Windows.Graphics.Display.Core.HdmiDisplayInformation item) => new RxHdmiDisplayInformationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHdmiDisplayInformationEvents + { + private readonly global::Windows.Graphics.Display.Core.HdmiDisplayInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHdmiDisplayInformationEvents(global::Windows.Graphics.Display.Core.HdmiDisplayInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args)> DisplayModesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisplayModesChanged += x, x => _data.DisplayModesChanged -= x); + } +} + +namespace Windows.Graphics.Holographic +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHolographicSpaceEvents Events(this global::Windows.Graphics.Holographic.HolographicSpace item) => new RxHolographicSpaceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHolographicSpaceEvents + { + private readonly global::Windows.Graphics.Holographic.HolographicSpace _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHolographicSpaceEvents(global::Windows.Graphics.Holographic.HolographicSpace data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args)> CameraAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraAdded += x, x => _data.CameraAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args)> CameraRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraRemoved += x, x => _data.CameraRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Holographic.HolographicSpace sender, object args)> UserPresenceChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Holographic.HolographicSpace sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserPresenceChanged += x, x => _data.UserPresenceChanged -= x); + } +} + +namespace Windows.Graphics.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintManagerEvents Events(this global::Windows.Graphics.Printing.PrintManager item) => new RxPrintManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintTaskEvents Events(this global::Windows.Graphics.Printing.PrintTask item) => new RxPrintTaskEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintManagerEvents + { + private readonly global::Windows.Graphics.Printing.PrintManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintManagerEvents(global::Windows.Graphics.Printing.PrintManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args)> PrintTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrintTaskRequested += x, x => _data.PrintTaskRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintTaskEvents + { + private readonly global::Windows.Graphics.Printing.PrintTask _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintTaskEvents(global::Windows.Graphics.Printing.PrintTask data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, object args)> Previewing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Previewing += x, x => _data.Previewing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args)> Progressing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Progressing += x, x => _data.Progressing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, object args)> Submitting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Submitting += x, x => _data.Submitting -= x); + } +} + +namespace Windows.Graphics.Printing.OptionDetails +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintTaskOptionDetailsEvents Events(this global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails item) => new RxPrintTaskOptionDetailsEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintTaskOptionDetailsEvents + { + private readonly global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintTaskOptionDetailsEvents(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args)> BeginValidation => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BeginValidation += x, x => _data.BeginValidation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args)> OptionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionChanged += x, x => _data.OptionChanged -= x); + } +} + +namespace Windows.Graphics.Printing.Workflow +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintWorkflowBackgroundSessionEvents Events(this global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession item) => new RxPrintWorkflowBackgroundSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintWorkflowForegroundSessionEvents Events(this global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession item) => new RxPrintWorkflowForegroundSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintWorkflowBackgroundSessionEvents + { + private readonly global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintWorkflowBackgroundSessionEvents(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args)> SetupRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args)> Submitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Submitted += x, x => _data.Submitted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintWorkflowForegroundSessionEvents + { + private readonly global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintWorkflowForegroundSessionEvents(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args)> SetupRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args)> XpsDataAvailable => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.XpsDataAvailable += x, x => _data.XpsDataAvailable -= x); + } +} + +namespace Windows.Graphics.Printing3D +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrint3DManagerEvents Events(this global::Windows.Graphics.Printing3D.Print3DManager item) => new RxPrint3DManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrint3DTaskEvents Events(this global::Windows.Graphics.Printing3D.Print3DTask item) => new RxPrint3DTaskEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrint3DManagerEvents + { + private readonly global::Windows.Graphics.Printing3D.Print3DManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrint3DManagerEvents(global::Windows.Graphics.Printing3D.Print3DManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing3D.Print3DManager sender, global::Windows.Graphics.Printing3D.Print3DTaskRequestedEventArgs args)> TaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing3D.Print3DManager sender, global::Windows.Graphics.Printing3D.Print3DTaskRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing3D.Print3DManager sender, global::Windows.Graphics.Printing3D.Print3DTaskRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TaskRequested += x, x => _data.TaskRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrint3DTaskEvents + { + private readonly global::Windows.Graphics.Printing3D.Print3DTask _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrint3DTaskEvents(global::Windows.Graphics.Printing3D.Print3DTask data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskSourceChangedEventArgs args)> SourceChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskSourceChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskSourceChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceChanged += x, x => _data.SourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing3D.Print3DTask sender, object args)> Submitting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing3D.Print3DTask sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing3D.Print3DTask sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Submitting += x, x => _data.Submitting -= x); + } +} + +namespace Windows.Management.Policies +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNamedPolicyDataEvents Events(this global::Windows.Management.Policies.NamedPolicyData item) => new RxNamedPolicyDataEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNamedPolicyDataEvents + { + private readonly global::Windows.Management.Policies.NamedPolicyData _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNamedPolicyDataEvents(global::Windows.Management.Policies.NamedPolicyData data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Management.Policies.NamedPolicyData sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Management.Policies.NamedPolicyData sender, object args)>(eventHandler => + { + void Handler(global::Windows.Management.Policies.NamedPolicyData sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaTimelineControllerEvents Events(this global::Windows.Media.MediaTimelineController item) => new RxMediaTimelineControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSystemMediaTransportControlsEvents Events(this global::Windows.Media.SystemMediaTransportControls item) => new RxSystemMediaTransportControlsEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaTimelineControllerEvents + { + private readonly global::Windows.Media.MediaTimelineController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaTimelineControllerEvents(global::Windows.Media.MediaTimelineController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, object args)> Ended => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Ended += x, x => _data.Ended -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args)> Failed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, object args)> PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSystemMediaTransportControlsEvents + { + private readonly global::Windows.Media.SystemMediaTransportControls _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSystemMediaTransportControlsEvents(global::Windows.Media.SystemMediaTransportControls data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args)> AutoRepeatModeChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutoRepeatModeChangeRequested += x, x => _data.AutoRepeatModeChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args)> ButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args)> PlaybackPositionChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackPositionChangeRequested += x, x => _data.PlaybackPositionChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args)> PlaybackRateChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args)> PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args)> ShuffleEnabledChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShuffleEnabledChangeRequested += x, x => _data.ShuffleEnabledChangeRequested -= x); + } +} + +namespace Windows.Media.AppBroadcasting +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastingMonitorEvents Events(this global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor item) => new RxAppBroadcastingMonitorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastingMonitorEvents + { + private readonly global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastingMonitorEvents(global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor sender, object args)> IsCurrentAppBroadcastingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsCurrentAppBroadcastingChanged += x, x => _data.IsCurrentAppBroadcastingChanged -= x); + } +} + +namespace Windows.Media.Audio +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioFileInputNodeEvents Events(this global::Windows.Media.Audio.AudioFileInputNode item) => new RxAudioFileInputNodeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioFrameInputNodeEvents Events(this global::Windows.Media.Audio.AudioFrameInputNode item) => new RxAudioFrameInputNodeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioGraphEvents Events(this global::Windows.Media.Audio.AudioGraph item) => new RxAudioGraphEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioPlaybackConnectionEvents Events(this global::Windows.Media.Audio.AudioPlaybackConnection item) => new RxAudioPlaybackConnectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioStateMonitorEvents Events(this global::Windows.Media.Audio.AudioStateMonitor item) => new RxAudioStateMonitorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaSourceAudioInputNodeEvents Events(this global::Windows.Media.Audio.MediaSourceAudioInputNode item) => new RxMediaSourceAudioInputNodeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialAudioDeviceConfigurationEvents Events(this global::Windows.Media.Audio.SpatialAudioDeviceConfiguration item) => new RxSpatialAudioDeviceConfigurationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioFileInputNodeEvents + { + private readonly global::Windows.Media.Audio.AudioFileInputNode _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioFileInputNodeEvents(global::Windows.Media.Audio.AudioFileInputNode data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioFileInputNode sender, object args)> FileCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioFileInputNode sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioFileInputNode sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FileCompleted += x, x => _data.FileCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioFrameInputNodeEvents + { + private readonly global::Windows.Media.Audio.AudioFrameInputNode _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioFrameInputNodeEvents(global::Windows.Media.Audio.AudioFrameInputNode data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args)> AudioFrameCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioFrameCompleted += x, x => _data.AudioFrameCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args)> QuantumStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioGraphEvents + { + private readonly global::Windows.Media.Audio.AudioGraph _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioGraphEvents(global::Windows.Media.Audio.AudioGraph data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioGraph sender, object args)> QuantumProcessed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioGraph sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuantumProcessed += x, x => _data.QuantumProcessed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioGraph sender, object args)> QuantumStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioGraph sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args)> UnrecoverableErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnrecoverableErrorOccurred += x, x => _data.UnrecoverableErrorOccurred -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioPlaybackConnectionEvents + { + private readonly global::Windows.Media.Audio.AudioPlaybackConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioPlaybackConnectionEvents(global::Windows.Media.Audio.AudioPlaybackConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioPlaybackConnection sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioPlaybackConnection sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioPlaybackConnection sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioStateMonitorEvents + { + private readonly global::Windows.Media.Audio.AudioStateMonitor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioStateMonitorEvents(global::Windows.Media.Audio.AudioStateMonitor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioStateMonitor sender, object args)> SoundLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioStateMonitor sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioStateMonitor sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SoundLevelChanged += x, x => _data.SoundLevelChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaSourceAudioInputNodeEvents + { + private readonly global::Windows.Media.Audio.MediaSourceAudioInputNode _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaSourceAudioInputNodeEvents(global::Windows.Media.Audio.MediaSourceAudioInputNode data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args)> MediaSourceCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaSourceCompleted += x, x => _data.MediaSourceCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialAudioDeviceConfigurationEvents + { + private readonly global::Windows.Media.Audio.SpatialAudioDeviceConfiguration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialAudioDeviceConfigurationEvents(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args)> ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + } +} + +namespace Windows.Media.Capture +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAdvancedPhotoCaptureEvents Events(this global::Windows.Media.Capture.AdvancedPhotoCapture item) => new RxAdvancedPhotoCaptureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastBackgroundServiceEvents Events(this global::Windows.Media.Capture.AppBroadcastBackgroundService item) => new RxAppBroadcastBackgroundServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastBackgroundServiceSignInInfoEvents Events(this global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo item) => new RxAppBroadcastBackgroundServiceSignInInfoEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastBackgroundServiceStreamInfoEvents Events(this global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo item) => new RxAppBroadcastBackgroundServiceStreamInfoEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastPreviewEvents Events(this global::Windows.Media.Capture.AppBroadcastPreview item) => new RxAppBroadcastPreviewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastPreviewStreamReaderEvents Events(this global::Windows.Media.Capture.AppBroadcastPreviewStreamReader item) => new RxAppBroadcastPreviewStreamReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastStateEvents Events(this global::Windows.Media.Capture.AppBroadcastState item) => new RxAppBroadcastStateEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastStreamReaderEvents Events(this global::Windows.Media.Capture.AppBroadcastStreamReader item) => new RxAppBroadcastStreamReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppCaptureEvents Events(this global::Windows.Media.Capture.AppCapture item) => new RxAppCaptureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppCaptureMetadataWriterEvents Events(this global::Windows.Media.Capture.AppCaptureMetadataWriter item) => new RxAppCaptureMetadataWriterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppCaptureRecordOperationEvents Events(this global::Windows.Media.Capture.AppCaptureRecordOperation item) => new RxAppCaptureRecordOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppCaptureStateEvents Events(this global::Windows.Media.Capture.AppCaptureState item) => new RxAppCaptureStateEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGameBarServicesEvents Events(this global::Windows.Media.Capture.GameBarServices item) => new RxGameBarServicesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGameBarServicesManagerEvents Events(this global::Windows.Media.Capture.GameBarServicesManager item) => new RxGameBarServicesManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLowLagPhotoSequenceCaptureEvents Events(this global::Windows.Media.Capture.LowLagPhotoSequenceCapture item) => new RxLowLagPhotoSequenceCaptureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaCaptureEvents Events(this global::Windows.Media.Capture.MediaCapture item) => new RxMediaCaptureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaCaptureRelativePanelWatcherEvents Events(this global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher item) => new RxMediaCaptureRelativePanelWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScreenCaptureEvents Events(this global::Windows.Media.Capture.ScreenCapture item) => new RxScreenCaptureEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAdvancedPhotoCaptureEvents + { + private readonly global::Windows.Media.Capture.AdvancedPhotoCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAdvancedPhotoCaptureEvents(global::Windows.Media.Capture.AdvancedPhotoCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args)> AllPhotosCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AllPhotosCaptured += x, x => _data.AllPhotosCaptured -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args)> OptionalReferencePhotoCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionalReferencePhotoCaptured += x, x => _data.OptionalReferencePhotoCaptured -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastBackgroundServiceEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastBackgroundService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastBackgroundServiceEvents(global::Windows.Media.Capture.AppBroadcastBackgroundService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)> BroadcastChannelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BroadcastChannelChanged += x, x => _data.BroadcastChannelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)> BroadcastLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BroadcastLanguageChanged += x, x => _data.BroadcastLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)> BroadcastTitleChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BroadcastTitleChanged += x, x => _data.BroadcastTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, global::Windows.Media.Capture.AppBroadcastHeartbeatRequestedEventArgs args)> HeartbeatRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundService sender, global::Windows.Media.Capture.AppBroadcastHeartbeatRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, global::Windows.Media.Capture.AppBroadcastHeartbeatRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeartbeatRequested += x, x => _data.HeartbeatRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastBackgroundServiceSignInInfoEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastBackgroundServiceSignInInfoEvents(global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, global::Windows.Media.Capture.AppBroadcastSignInStateChangedEventArgs args)> SignInStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, global::Windows.Media.Capture.AppBroadcastSignInStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, global::Windows.Media.Capture.AppBroadcastSignInStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SignInStateChanged += x, x => _data.SignInStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, object args)> UserNameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserNameChanged += x, x => _data.UserNameChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastBackgroundServiceStreamInfoEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastBackgroundServiceStreamInfoEvents(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args)> StreamStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StreamStateChanged += x, x => _data.StreamStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args)> VideoEncodingBitrateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoEncodingBitrateChanged += x, x => _data.VideoEncodingBitrateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args)> VideoEncodingResolutionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoEncodingResolutionChanged += x, x => _data.VideoEncodingResolutionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastPreviewEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastPreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastPreviewEvents(global::Windows.Media.Capture.AppBroadcastPreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastPreview sender, global::Windows.Media.Capture.AppBroadcastPreviewStateChangedEventArgs args)> PreviewStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastPreview sender, global::Windows.Media.Capture.AppBroadcastPreviewStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastPreview sender, global::Windows.Media.Capture.AppBroadcastPreviewStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PreviewStateChanged += x, x => _data.PreviewStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastPreviewStreamReaderEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastPreviewStreamReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastPreviewStreamReaderEvents(global::Windows.Media.Capture.AppBroadcastPreviewStreamReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastPreviewStreamReader sender, object args)> VideoFrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastPreviewStreamReader sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastPreviewStreamReader sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoFrameArrived += x, x => _data.VideoFrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastStateEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastState _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastStateEvents(global::Windows.Media.Capture.AppBroadcastState data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastCameraCaptureStateChangedEventArgs args)> CameraCaptureStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastCameraCaptureStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastCameraCaptureStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraCaptureStateChanged += x, x => _data.CameraCaptureStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, object args)> CaptureTargetClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CaptureTargetClosed += x, x => _data.CaptureTargetClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastMicrophoneCaptureStateChangedEventArgs args)> MicrophoneCaptureStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastMicrophoneCaptureStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastMicrophoneCaptureStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MicrophoneCaptureStateChanged += x, x => _data.MicrophoneCaptureStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastPlugInStateChangedEventArgs args)> PlugInStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastPlugInStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastPlugInStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlugInStateChanged += x, x => _data.PlugInStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args)> StreamStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StreamStateChanged += x, x => _data.StreamStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastViewerCountChangedEventArgs args)> ViewerCountChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastViewerCountChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastViewerCountChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ViewerCountChanged += x, x => _data.ViewerCountChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastStreamReaderEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastStreamReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastStreamReaderEvents(global::Windows.Media.Capture.AppBroadcastStreamReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args)> AudioFrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioFrameArrived += x, x => _data.AudioFrameArrived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args)> VideoFrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoFrameArrived += x, x => _data.VideoFrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppCaptureEvents + { + private readonly global::Windows.Media.Capture.AppCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppCaptureEvents(global::Windows.Media.Capture.AppCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCapture sender, object args)> CapturingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCapture sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCapture sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CapturingChanged += x, x => _data.CapturingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppCaptureMetadataWriterEvents + { + private readonly global::Windows.Media.Capture.AppCaptureMetadataWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppCaptureMetadataWriterEvents(global::Windows.Media.Capture.AppCaptureMetadataWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureMetadataWriter sender, object args)> MetadataPurged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureMetadataWriter sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureMetadataWriter sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MetadataPurged += x, x => _data.MetadataPurged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppCaptureRecordOperationEvents + { + private readonly global::Windows.Media.Capture.AppCaptureRecordOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppCaptureRecordOperationEvents(global::Windows.Media.Capture.AppCaptureRecordOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureDurationGeneratedEventArgs args)> DurationGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureDurationGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureDurationGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DurationGenerated += x, x => _data.DurationGenerated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureFileGeneratedEventArgs args)> FileGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureFileGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureFileGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FileGenerated += x, x => _data.FileGenerated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureRecordingStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureRecordingStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureRecordingStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppCaptureStateEvents + { + private readonly global::Windows.Media.Capture.AppCaptureState _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppCaptureStateEvents(global::Windows.Media.Capture.AppCaptureState data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureState sender, object args)> CaptureTargetClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureState sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureState sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CaptureTargetClosed += x, x => _data.CaptureTargetClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureState sender, global::Windows.Media.Capture.AppCaptureMicrophoneCaptureStateChangedEventArgs args)> MicrophoneCaptureStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureState sender, global::Windows.Media.Capture.AppCaptureMicrophoneCaptureStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureState sender, global::Windows.Media.Capture.AppCaptureMicrophoneCaptureStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MicrophoneCaptureStateChanged += x, x => _data.MicrophoneCaptureStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGameBarServicesEvents + { + private readonly global::Windows.Media.Capture.GameBarServices _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGameBarServicesEvents(global::Windows.Media.Capture.GameBarServices data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.GameBarServices sender, global::Windows.Media.Capture.GameBarServicesCommandEventArgs args)> CommandReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.GameBarServices sender, global::Windows.Media.Capture.GameBarServicesCommandEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.GameBarServices sender, global::Windows.Media.Capture.GameBarServicesCommandEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CommandReceived += x, x => _data.CommandReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGameBarServicesManagerEvents + { + private readonly global::Windows.Media.Capture.GameBarServicesManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGameBarServicesManagerEvents(global::Windows.Media.Capture.GameBarServicesManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.GameBarServicesManager sender, global::Windows.Media.Capture.GameBarServicesManagerGameBarServicesCreatedEventArgs args)> GameBarServicesCreated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.GameBarServicesManager sender, global::Windows.Media.Capture.GameBarServicesManagerGameBarServicesCreatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.GameBarServicesManager sender, global::Windows.Media.Capture.GameBarServicesManagerGameBarServicesCreatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GameBarServicesCreated += x, x => _data.GameBarServicesCreated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLowLagPhotoSequenceCaptureEvents + { + private readonly global::Windows.Media.Capture.LowLagPhotoSequenceCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLowLagPhotoSequenceCaptureEvents(global::Windows.Media.Capture.LowLagPhotoSequenceCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args)> PhotoCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaCaptureEvents + { + private readonly global::Windows.Media.Capture.MediaCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaCaptureEvents(global::Windows.Media.Capture.MediaCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, object args)> CameraStreamStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraStreamStateChanged += x, x => _data.CameraStreamStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args)> CaptureDeviceExclusiveControlStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CaptureDeviceExclusiveControlStatusChanged += x, x => _data.CaptureDeviceExclusiveControlStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFailedEventArgs errorEventArgs)> Failed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFailedEventArgs errorEventArgs) => eventHandler((sender, errorEventArgs)); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args)> FocusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FocusChanged += x, x => _data.FocusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args)> PhotoConfirmationCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PhotoConfirmationCaptured += x, x => _data.PhotoConfirmationCaptured -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecordLimitationExceeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender) => eventHandler(sender); + return Handler; + }, x => _data.RecordLimitationExceeded += x, x => _data.RecordLimitationExceeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, object args)> ThermalStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ThermalStatusChanged += x, x => _data.ThermalStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaCaptureRelativePanelWatcherEvents + { + private readonly global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaCaptureRelativePanelWatcherEvents(global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScreenCaptureEvents + { + private readonly global::Windows.Media.Capture.ScreenCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScreenCaptureEvents(global::Windows.Media.Capture.ScreenCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args)> SourceSuspensionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceSuspensionChanged += x, x => _data.SourceSuspensionChanged -= x); + } +} + +namespace Windows.Media.Capture.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVariablePhotoSequenceCaptureEvents Events(this global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture item) => new RxVariablePhotoSequenceCaptureEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVariablePhotoSequenceCaptureEvents + { + private readonly global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVariablePhotoSequenceCaptureEvents(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args)> PhotoCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } +} + +namespace Windows.Media.Capture.Frames +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaFrameReaderEvents Events(this global::Windows.Media.Capture.Frames.MediaFrameReader item) => new RxMediaFrameReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaFrameSourceEvents Events(this global::Windows.Media.Capture.Frames.MediaFrameSource item) => new RxMediaFrameSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMultiSourceMediaFrameReaderEvents Events(this global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader item) => new RxMultiSourceMediaFrameReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaFrameReaderEvents + { + private readonly global::Windows.Media.Capture.Frames.MediaFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaFrameReaderEvents(global::Windows.Media.Capture.Frames.MediaFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaFrameSourceEvents + { + private readonly global::Windows.Media.Capture.Frames.MediaFrameSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaFrameSourceEvents(global::Windows.Media.Capture.Frames.MediaFrameSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args)> FormatChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMultiSourceMediaFrameReaderEvents + { + private readonly global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMultiSourceMediaFrameReaderEvents(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } +} + +namespace Windows.Media.Casting +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCastingConnectionEvents Events(this global::Windows.Media.Casting.CastingConnection item) => new RxCastingConnectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCastingDevicePickerEvents Events(this global::Windows.Media.Casting.CastingDevicePicker item) => new RxCastingDevicePickerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCastingConnectionEvents + { + private readonly global::Windows.Media.Casting.CastingConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCastingConnectionEvents(global::Windows.Media.Casting.CastingConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Casting.CastingConnection sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingConnection sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Casting.CastingConnection sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCastingDevicePickerEvents + { + private readonly global::Windows.Media.Casting.CastingDevicePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCastingDevicePickerEvents(global::Windows.Media.Casting.CastingDevicePicker data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Casting.CastingDevicePicker sender, object args)> CastingDevicePickerDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingDevicePicker sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CastingDevicePickerDismissed += x, x => _data.CastingDevicePickerDismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args)> CastingDeviceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CastingDeviceSelected += x, x => _data.CastingDeviceSelected -= x); + } +} + +namespace Windows.Media.ContentRestrictions +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRatedContentRestrictionsEvents Events(this global::Windows.Media.ContentRestrictions.RatedContentRestrictions item) => new RxRatedContentRestrictionsEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRatedContentRestrictionsEvents + { + private readonly global::Windows.Media.ContentRestrictions.RatedContentRestrictions _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRatedContentRestrictionsEvents(global::Windows.Media.ContentRestrictions.RatedContentRestrictions data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RestrictionsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.RestrictionsChanged += x, x => _data.RestrictionsChanged -= x); + } +} + +namespace Windows.Media.Control +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGlobalSystemMediaTransportControlsSessionEvents Events(this global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession item) => new RxGlobalSystemMediaTransportControlsSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGlobalSystemMediaTransportControlsSessionManagerEvents Events(this global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager item) => new RxGlobalSystemMediaTransportControlsSessionManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGlobalSystemMediaTransportControlsSessionEvents + { + private readonly global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGlobalSystemMediaTransportControlsSessionEvents(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args)> MediaPropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaPropertiesChanged += x, x => _data.MediaPropertiesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args)> PlaybackInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackInfoChanged += x, x => _data.PlaybackInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args)> TimelinePropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TimelinePropertiesChanged += x, x => _data.TimelinePropertiesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGlobalSystemMediaTransportControlsSessionManagerEvents + { + private readonly global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGlobalSystemMediaTransportControlsSessionManagerEvents(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args)> CurrentSessionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CurrentSessionChanged += x, x => _data.CurrentSessionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args)> SessionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionsChanged += x, x => _data.SessionsChanged -= x); + } +} + +namespace Windows.Media.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioTrackEvents Events(this global::Windows.Media.Core.AudioTrack item) => new RxAudioTrackEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFaceDetectionEffectEvents Events(this global::Windows.Media.Core.FaceDetectionEffect item) => new RxFaceDetectionEffectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxISingleSelectMediaTrackListEvents Events(this global::Windows.Media.Core.ISingleSelectMediaTrackList item) => new RxISingleSelectMediaTrackListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaBinderEvents Events(this global::Windows.Media.Core.MediaBinder item) => new RxMediaBinderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaBindingEventArgsEvents Events(this global::Windows.Media.Core.MediaBindingEventArgs item) => new RxMediaBindingEventArgsEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaSourceEvents Events(this global::Windows.Media.Core.MediaSource item) => new RxMediaSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaSourceAppServiceConnectionEvents Events(this global::Windows.Media.Core.MediaSourceAppServiceConnection item) => new RxMediaSourceAppServiceConnectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaStreamSampleEvents Events(this global::Windows.Media.Core.MediaStreamSample item) => new RxMediaStreamSampleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaStreamSourceEvents Events(this global::Windows.Media.Core.MediaStreamSource item) => new RxMediaStreamSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMseSourceBufferEvents Events(this global::Windows.Media.Core.MseSourceBuffer item) => new RxMseSourceBufferEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMseSourceBufferListEvents Events(this global::Windows.Media.Core.MseSourceBufferList item) => new RxMseSourceBufferListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMseStreamSourceEvents Events(this global::Windows.Media.Core.MseStreamSource item) => new RxMseStreamSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSceneAnalysisEffectEvents Events(this global::Windows.Media.Core.SceneAnalysisEffect item) => new RxSceneAnalysisEffectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimedMetadataTrackEvents Events(this global::Windows.Media.Core.TimedMetadataTrack item) => new RxTimedMetadataTrackEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimedTextSourceEvents Events(this global::Windows.Media.Core.TimedTextSource item) => new RxTimedTextSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVideoStabilizationEffectEvents Events(this global::Windows.Media.Core.VideoStabilizationEffect item) => new RxVideoStabilizationEffectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVideoTrackEvents Events(this global::Windows.Media.Core.VideoTrack item) => new RxVideoTrackEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioTrackEvents + { + private readonly global::Windows.Media.Core.AudioTrack _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioTrackEvents(global::Windows.Media.Core.AudioTrack data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args)> OpenFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFaceDetectionEffectEvents + { + private readonly global::Windows.Media.Core.FaceDetectionEffect _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFaceDetectionEffectEvents(global::Windows.Media.Core.FaceDetectionEffect data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args)> FaceDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FaceDetected += x, x => _data.FaceDetected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxISingleSelectMediaTrackListEvents + { + private readonly global::Windows.Media.Core.ISingleSelectMediaTrackList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxISingleSelectMediaTrackListEvents(global::Windows.Media.Core.ISingleSelectMediaTrackList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)> SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaBinderEvents + { + private readonly global::Windows.Media.Core.MediaBinder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaBinderEvents(global::Windows.Media.Core.MediaBinder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args)> Binding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Binding += x, x => _data.Binding -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaBindingEventArgsEvents + { + private readonly global::Windows.Media.Core.MediaBindingEventArgs _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaBindingEventArgsEvents(global::Windows.Media.Core.MediaBindingEventArgs data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaBindingEventArgs sender, object args)> Canceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaBindingEventArgs sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaBindingEventArgs sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Canceled += x, x => _data.Canceled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaSourceEvents + { + private readonly global::Windows.Media.Core.MediaSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaSourceEvents(global::Windows.Media.Core.MediaSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args)> OpenOperationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OpenOperationCompleted += x, x => _data.OpenOperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaSourceAppServiceConnectionEvents + { + private readonly global::Windows.Media.Core.MediaSourceAppServiceConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaSourceAppServiceConnectionEvents(global::Windows.Media.Core.MediaSourceAppServiceConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args)> InitializeMediaStreamSourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InitializeMediaStreamSourceRequested += x, x => _data.InitializeMediaStreamSourceRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaStreamSampleEvents + { + private readonly global::Windows.Media.Core.MediaStreamSample _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaStreamSampleEvents(global::Windows.Media.Core.MediaStreamSample data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSample sender, object args)> Processed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSample sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSample sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Processed += x, x => _data.Processed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaStreamSourceEvents + { + private readonly global::Windows.Media.Core.MediaStreamSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaStreamSourceEvents(global::Windows.Media.Core.MediaStreamSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, object args)> Paused => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Paused += x, x => _data.Paused -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args)> SampleRendered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SampleRendered += x, x => _data.SampleRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args)> SampleRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SampleRequested += x, x => _data.SampleRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args)> Starting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Starting += x, x => _data.Starting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args)> SwitchStreamsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SwitchStreamsRequested += x, x => _data.SwitchStreamsRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMseSourceBufferEvents + { + private readonly global::Windows.Media.Core.MseSourceBuffer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMseSourceBufferEvents(global::Windows.Media.Core.MseSourceBuffer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> Aborted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> UpdateEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UpdateEnded += x, x => _data.UpdateEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> UpdateStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UpdateStarting += x, x => _data.UpdateStarting -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMseSourceBufferListEvents + { + private readonly global::Windows.Media.Core.MseSourceBufferList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMseSourceBufferListEvents(global::Windows.Media.Core.MseSourceBufferList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBufferList sender, object args)> SourceBufferAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBufferList sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceBufferAdded += x, x => _data.SourceBufferAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBufferList sender, object args)> SourceBufferRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBufferList sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceBufferRemoved += x, x => _data.SourceBufferRemoved -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMseStreamSourceEvents + { + private readonly global::Windows.Media.Core.MseStreamSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMseStreamSourceEvents(global::Windows.Media.Core.MseStreamSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseStreamSource sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseStreamSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseStreamSource sender, object args)> Ended => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseStreamSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Ended += x, x => _data.Ended -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseStreamSource sender, object args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseStreamSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSceneAnalysisEffectEvents + { + private readonly global::Windows.Media.Core.SceneAnalysisEffect _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSceneAnalysisEffectEvents(global::Windows.Media.Core.SceneAnalysisEffect data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args)> SceneAnalyzed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SceneAnalyzed += x, x => _data.SceneAnalyzed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimedMetadataTrackEvents + { + private readonly global::Windows.Media.Core.TimedMetadataTrack _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimedMetadataTrackEvents(global::Windows.Media.Core.TimedMetadataTrack data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)> CueEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CueEntered += x, x => _data.CueEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)> CueExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CueExited += x, x => _data.CueExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args)> TrackFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TrackFailed += x, x => _data.TrackFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimedTextSourceEvents + { + private readonly global::Windows.Media.Core.TimedTextSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimedTextSourceEvents(global::Windows.Media.Core.TimedTextSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args)> Resolved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Resolved += x, x => _data.Resolved -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVideoStabilizationEffectEvents + { + private readonly global::Windows.Media.Core.VideoStabilizationEffect _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVideoStabilizationEffectEvents(global::Windows.Media.Core.VideoStabilizationEffect data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args)> EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVideoTrackEvents + { + private readonly global::Windows.Media.Core.VideoTrack _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVideoTrackEvents(global::Windows.Media.Core.VideoTrack data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args)> OpenFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + } +} + +namespace Windows.Media.Devices +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioDeviceModulesManagerEvents Events(this global::Windows.Media.Devices.AudioDeviceModulesManager item) => new RxAudioDeviceModulesManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCallControlEvents Events(this global::Windows.Media.Devices.CallControl item) => new RxCallControlEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioDeviceModulesManagerEvents + { + private readonly global::Windows.Media.Devices.AudioDeviceModulesManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioDeviceModulesManagerEvents(global::Windows.Media.Devices.AudioDeviceModulesManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args)> ModuleNotificationReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ModuleNotificationReceived += x, x => _data.ModuleNotificationReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCallControlEvents + { + private readonly global::Windows.Media.Devices.CallControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCallControlEvents(global::Windows.Media.Devices.CallControl data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnswerRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender) => eventHandler(sender); + return Handler; + }, x => _data.AnswerRequested += x, x => _data.AnswerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AudioTransferRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender) => eventHandler(sender); + return Handler; + }, x => _data.AudioTransferRequested += x, x => _data.AudioTransferRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.DialRequestedEventArgs e)> DialRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.DialRequestedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.DialRequested += x, x => _data.DialRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HangUpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender) => eventHandler(sender); + return Handler; + }, x => _data.HangUpRequested += x, x => _data.HangUpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.KeypadPressedEventArgs e)> KeypadPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.KeypadPressedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.KeypadPressed += x, x => _data.KeypadPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.RedialRequestedEventArgs e)> RedialRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.RedialRequestedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.RedialRequested += x, x => _data.RedialRequested -= x); + } +} + +namespace Windows.Media.DialProtocol +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDialDevicePickerEvents Events(this global::Windows.Media.DialProtocol.DialDevicePicker item) => new RxDialDevicePickerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDialDevicePickerEvents + { + private readonly global::Windows.Media.DialProtocol.DialDevicePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDialDevicePickerEvents(global::Windows.Media.DialProtocol.DialDevicePicker data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.DialProtocol.DialDevicePicker sender, object args)> DialDevicePickerDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.DialProtocol.DialDevicePicker sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DialDevicePickerDismissed += x, x => _data.DialDevicePickerDismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args)> DialDeviceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DialDeviceSelected += x, x => _data.DialDeviceSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args)> DisconnectButtonClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + } +} + +namespace Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioCaptureEffectsManagerEvents Events(this global::Windows.Media.Effects.AudioCaptureEffectsManager item) => new RxAudioCaptureEffectsManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioRenderEffectsManagerEvents Events(this global::Windows.Media.Effects.AudioRenderEffectsManager item) => new RxAudioRenderEffectsManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioCaptureEffectsManagerEvents + { + private readonly global::Windows.Media.Effects.AudioCaptureEffectsManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioCaptureEffectsManagerEvents(global::Windows.Media.Effects.AudioCaptureEffectsManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args)> AudioCaptureEffectsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioCaptureEffectsChanged += x, x => _data.AudioCaptureEffectsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioRenderEffectsManagerEvents + { + private readonly global::Windows.Media.Effects.AudioRenderEffectsManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioRenderEffectsManagerEvents(global::Windows.Media.Effects.AudioRenderEffectsManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args)> AudioRenderEffectsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioRenderEffectsChanged += x, x => _data.AudioRenderEffectsChanged -= x); + } +} + +namespace Windows.Media.Import +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPhotoImportFindItemsResultEvents Events(this global::Windows.Media.Import.PhotoImportFindItemsResult item) => new RxPhotoImportFindItemsResultEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPhotoImportFindItemsResultEvents + { + private readonly global::Windows.Media.Import.PhotoImportFindItemsResult _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPhotoImportFindItemsResultEvents(global::Windows.Media.Import.PhotoImportFindItemsResult data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args)> ItemImported => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemImported += x, x => _data.ItemImported -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args)> SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } +} + +namespace Windows.Media.Miracast +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMiracastReceiverEvents Events(this global::Windows.Media.Miracast.MiracastReceiver item) => new RxMiracastReceiverEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMiracastReceiverCursorImageChannelEvents Events(this global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel item) => new RxMiracastReceiverCursorImageChannelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMiracastReceiverGameControllerDeviceEvents Events(this global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice item) => new RxMiracastReceiverGameControllerDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMiracastReceiverKeyboardDeviceEvents Events(this global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice item) => new RxMiracastReceiverKeyboardDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMiracastReceiverSessionEvents Events(this global::Windows.Media.Miracast.MiracastReceiverSession item) => new RxMiracastReceiverSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMiracastReceiverEvents + { + private readonly global::Windows.Media.Miracast.MiracastReceiver _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMiracastReceiverEvents(global::Windows.Media.Miracast.MiracastReceiver data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiver sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMiracastReceiverCursorImageChannelEvents + { + private readonly global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMiracastReceiverCursorImageChannelEvents(global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args)> ImageStreamChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ImageStreamChanged += x, x => _data.ImageStreamChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args)> PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMiracastReceiverGameControllerDeviceEvents + { + private readonly global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMiracastReceiverGameControllerDeviceEvents(global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMiracastReceiverKeyboardDeviceEvents + { + private readonly global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMiracastReceiverKeyboardDeviceEvents(global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMiracastReceiverSessionEvents + { + private readonly global::Windows.Media.Miracast.MiracastReceiverSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMiracastReceiverSessionEvents(global::Windows.Media.Miracast.MiracastReceiverSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverConnectionCreatedEventArgs args)> ConnectionCreated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverConnectionCreatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverConnectionCreatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionCreated += x, x => _data.ConnectionCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverDisconnectedEventArgs args)> Disconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverDisconnectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverDisconnectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Disconnected += x, x => _data.Disconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverMediaSourceCreatedEventArgs args)> MediaSourceCreated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverMediaSourceCreatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverMediaSourceCreatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaSourceCreated += x, x => _data.MediaSourceCreated -= x); + } +} + +namespace Windows.Media.Playback +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaBreakManagerEvents Events(this global::Windows.Media.Playback.MediaBreakManager item) => new RxMediaBreakManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaBreakScheduleEvents Events(this global::Windows.Media.Playback.MediaBreakSchedule item) => new RxMediaBreakScheduleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackAudioTrackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackAudioTrackList item) => new RxMediaPlaybackAudioTrackListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackCommandManagerEvents Events(this global::Windows.Media.Playback.MediaPlaybackCommandManager item) => new RxMediaPlaybackCommandManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackCommandManagerCommandBehaviorEvents Events(this global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior item) => new RxMediaPlaybackCommandManagerCommandBehaviorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackItemEvents Events(this global::Windows.Media.Playback.MediaPlaybackItem item) => new RxMediaPlaybackItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackList item) => new RxMediaPlaybackListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackSessionEvents Events(this global::Windows.Media.Playback.MediaPlaybackSession item) => new RxMediaPlaybackSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackTimedMetadataTrackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList item) => new RxMediaPlaybackTimedMetadataTrackListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackVideoTrackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackVideoTrackList item) => new RxMediaPlaybackVideoTrackListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::Windows.Media.Playback.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaBreakManagerEvents + { + private readonly global::Windows.Media.Playback.MediaBreakManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaBreakManagerEvents(global::Windows.Media.Playback.MediaBreakManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args)> BreakEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BreakEnded += x, x => _data.BreakEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args)> BreakSkipped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BreakSkipped += x, x => _data.BreakSkipped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args)> BreaksSeekedOver => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BreaksSeekedOver += x, x => _data.BreaksSeekedOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args)> BreakStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BreakStarted += x, x => _data.BreakStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaBreakScheduleEvents + { + private readonly global::Windows.Media.Playback.MediaBreakSchedule _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaBreakScheduleEvents(global::Windows.Media.Playback.MediaBreakSchedule data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakSchedule sender, object args)> ScheduleChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakSchedule sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaBreakSchedule sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScheduleChanged += x, x => _data.ScheduleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackAudioTrackListEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackAudioTrackList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackAudioTrackListEvents(global::Windows.Media.Playback.MediaPlaybackAudioTrackList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)> SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackCommandManagerEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackCommandManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackCommandManagerEvents(global::Windows.Media.Playback.MediaPlaybackCommandManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args)> AutoRepeatModeReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutoRepeatModeReceived += x, x => _data.AutoRepeatModeReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args)> FastForwardReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FastForwardReceived += x, x => _data.FastForwardReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args)> NextReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NextReceived += x, x => _data.NextReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args)> PauseReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PauseReceived += x, x => _data.PauseReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args)> PlayReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlayReceived += x, x => _data.PlayReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args)> PositionReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionReceived += x, x => _data.PositionReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args)> PreviousReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PreviousReceived += x, x => _data.PreviousReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args)> RateReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RateReceived += x, x => _data.RateReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args)> RewindReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RewindReceived += x, x => _data.RewindReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args)> ShuffleReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShuffleReceived += x, x => _data.ShuffleReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackCommandManagerCommandBehaviorEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackCommandManagerCommandBehaviorEvents(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args)> IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackItemEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackItemEvents(global::Windows.Media.Playback.MediaPlaybackItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)> AudioTracksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioTracksChanged += x, x => _data.AudioTracksChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)> TimedMetadataTracksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TimedMetadataTracksChanged += x, x => _data.TimedMetadataTracksChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)> VideoTracksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoTracksChanged += x, x => _data.VideoTracksChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackListEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackListEvents(global::Windows.Media.Playback.MediaPlaybackList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args)> CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args)> ItemFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemFailed += x, x => _data.ItemFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args)> ItemOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemOpened += x, x => _data.ItemOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackSessionEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackSessionEvents(global::Windows.Media.Playback.MediaPlaybackSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferedRangesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferedRangesChanged += x, x => _data.BufferedRangesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> DownloadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> NaturalDurationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NaturalDurationChanged += x, x => _data.NaturalDurationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> NaturalVideoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NaturalVideoSizeChanged += x, x => _data.NaturalVideoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PlaybackRateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackRateChanged += x, x => _data.PlaybackRateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PlaybackStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackStateChanged += x, x => _data.PlaybackStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PlayedRangesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlayedRangesChanged += x, x => _data.PlayedRangesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> SeekableRangesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SeekableRangesChanged += x, x => _data.SeekableRangesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> SeekCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> SupportedPlaybackRatesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SupportedPlaybackRatesChanged += x, x => _data.SupportedPlaybackRatesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackTimedMetadataTrackListEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackTimedMetadataTrackListEvents(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args)> PresentationModeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PresentationModeChanged += x, x => _data.PresentationModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackVideoTrackListEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackVideoTrackList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackVideoTrackListEvents(global::Windows.Media.Playback.MediaPlaybackVideoTrackList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)> SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents + { + private readonly global::Windows.Media.Playback.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::Windows.Media.Playback.MediaPlayer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> IsMutedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsMutedChanged += x, x => _data.IsMutedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> MediaEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args)> MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> MediaOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args)> MediaPlayerRateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaPlayerRateChanged += x, x => _data.MediaPlayerRateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args)> PlaybackMediaMarkerReached => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackMediaMarkerReached += x, x => _data.PlaybackMediaMarkerReached -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> SeekCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> SourceChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceChanged += x, x => _data.SourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> SubtitleFrameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SubtitleFrameChanged += x, x => _data.SubtitleFrameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> VideoFrameAvailable => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoFrameAvailable += x, x => _data.VideoFrameAvailable -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> VolumeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + } +} + +namespace Windows.Media.PlayTo +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPlayToConnectionEvents Events(this global::Windows.Media.PlayTo.PlayToConnection item) => new RxPlayToConnectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPlayToManagerEvents Events(this global::Windows.Media.PlayTo.PlayToManager item) => new RxPlayToManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPlayToReceiverEvents Events(this global::Windows.Media.PlayTo.PlayToReceiver item) => new RxPlayToReceiverEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPlayToConnectionEvents + { + private readonly global::Windows.Media.PlayTo.PlayToConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPlayToConnectionEvents(global::Windows.Media.PlayTo.PlayToConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args)> Error => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args)> Transferred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Transferred += x, x => _data.Transferred -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPlayToManagerEvents + { + private readonly global::Windows.Media.PlayTo.PlayToManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPlayToManagerEvents(global::Windows.Media.PlayTo.PlayToManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args)> SourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceRequested += x, x => _data.SourceRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args)> SourceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceSelected += x, x => _data.SourceSelected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPlayToReceiverEvents + { + private readonly global::Windows.Media.PlayTo.PlayToReceiver _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPlayToReceiverEvents(global::Windows.Media.PlayTo.PlayToReceiver data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args)> CurrentTimeChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CurrentTimeChangeRequested += x, x => _data.CurrentTimeChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args)> MuteChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MuteChangeRequested += x, x => _data.MuteChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> PauseRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PauseRequested += x, x => _data.PauseRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args)> PlaybackRateChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> PlayRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlayRequested += x, x => _data.PlayRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args)> SourceChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceChangeRequested += x, x => _data.SourceChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> StopRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StopRequested += x, x => _data.StopRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> TimeUpdateRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TimeUpdateRequested += x, x => _data.TimeUpdateRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args)> VolumeChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VolumeChangeRequested += x, x => _data.VolumeChangeRequested -= x); + } +} + +namespace Windows.Media.Protection +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHdcpSessionEvents Events(this global::Windows.Media.Protection.HdcpSession item) => new RxHdcpSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaProtectionManagerEvents Events(this global::Windows.Media.Protection.MediaProtectionManager item) => new RxMediaProtectionManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHdcpSessionEvents + { + private readonly global::Windows.Media.Protection.HdcpSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHdcpSessionEvents(global::Windows.Media.Protection.HdcpSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.HdcpSession sender, object args)> ProtectionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.HdcpSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.HdcpSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProtectionChanged += x, x => _data.ProtectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaProtectionManagerEvents + { + private readonly global::Windows.Media.Protection.MediaProtectionManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaProtectionManagerEvents(global::Windows.Media.Protection.MediaProtectionManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ComponentLoadFailedEventArgs e)> ComponentLoadFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ComponentLoadFailedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.ComponentLoadFailed += x, x => _data.ComponentLoadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RebootNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Protection.MediaProtectionManager sender) => eventHandler(sender); + return Handler; + }, x => _data.RebootNeeded += x, x => _data.RebootNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ServiceRequestedEventArgs e)> ServiceRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ServiceRequestedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.ServiceRequested += x, x => _data.ServiceRequested -= x); + } +} + +namespace Windows.Media.Protection.PlayReady +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNDClientEvents Events(this global::Windows.Media.Protection.PlayReady.NDClient item) => new RxNDClientEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNDClientEvents + { + private readonly global::Windows.Media.Protection.PlayReady.NDClient _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNDClientEvents(global::Windows.Media.Protection.PlayReady.NDClient data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args)> ClosedCaptionDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ClosedCaptionDataReceived += x, x => _data.ClosedCaptionDataReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args)> LicenseFetchCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LicenseFetchCompleted += x, x => _data.LicenseFetchCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args)> ProximityDetectionCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProximityDetectionCompleted += x, x => _data.ProximityDetectionCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args)> RegistrationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RegistrationCompleted += x, x => _data.RegistrationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, object args)> ReRegistrationNeeded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReRegistrationNeeded += x, x => _data.ReRegistrationNeeded -= x); + } +} + +namespace Windows.Media.SpeechRecognition +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpeechContinuousRecognitionSessionEvents Events(this global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession item) => new RxSpeechContinuousRecognitionSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpeechRecognizerEvents Events(this global::Windows.Media.SpeechRecognition.SpeechRecognizer item) => new RxSpeechRecognizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpeechContinuousRecognitionSessionEvents + { + private readonly global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpeechContinuousRecognitionSessionEvents(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args)> ResultGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResultGenerated += x, x => _data.ResultGenerated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpeechRecognizerEvents + { + private readonly global::Windows.Media.SpeechRecognition.SpeechRecognizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpeechRecognizerEvents(global::Windows.Media.SpeechRecognition.SpeechRecognizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args)> HypothesisGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HypothesisGenerated += x, x => _data.HypothesisGenerated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args)> RecognitionQualityDegrading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RecognitionQualityDegrading += x, x => _data.RecognitionQualityDegrading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace Windows.Media.Streaming.Adaptive +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAdaptiveMediaSourceEvents Events(this global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource item) => new RxAdaptiveMediaSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAdaptiveMediaSourceDiagnosticsEvents Events(this global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics item) => new RxAdaptiveMediaSourceDiagnosticsEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAdaptiveMediaSourceEvents + { + private readonly global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAdaptiveMediaSourceEvents(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args)> DownloadBitrateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadBitrateChanged += x, x => _data.DownloadBitrateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args)> DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args)> DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args)> DownloadRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadRequested += x, x => _data.DownloadRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args)> PlaybackBitrateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackBitrateChanged += x, x => _data.PlaybackBitrateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAdaptiveMediaSourceDiagnosticsEvents + { + private readonly global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAdaptiveMediaSourceDiagnosticsEvents(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args)> DiagnosticAvailable => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DiagnosticAvailable += x, x => _data.DiagnosticAvailable -= x); + } +} + +namespace Windows.Networking.BackgroundTransfer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDownloadOperationEvents Events(this global::Windows.Networking.BackgroundTransfer.DownloadOperation item) => new RxDownloadOperationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDownloadOperationEvents + { + private readonly global::Windows.Networking.BackgroundTransfer.DownloadOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDownloadOperationEvents(global::Windows.Networking.BackgroundTransfer.DownloadOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args)> RangesDownloaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RangesDownloaded += x, x => _data.RangesDownloaded -= x); + } +} + +namespace Windows.Networking.NetworkOperators +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxESimEvents Events(this global::Windows.Networking.NetworkOperators.ESim item) => new RxESimEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxESimProfileMetadataEvents Events(this global::Windows.Networking.NetworkOperators.ESimProfileMetadata item) => new RxESimProfileMetadataEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxESimWatcherEvents Events(this global::Windows.Networking.NetworkOperators.ESimWatcher item) => new RxESimWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMobileBroadbandAccountWatcherEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher item) => new RxMobileBroadbandAccountWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMobileBroadbandDeviceServiceDataSessionEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession item) => new RxMobileBroadbandDeviceServiceDataSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMobileBroadbandModemEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandModem item) => new RxMobileBroadbandModemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMobileBroadbandSarManagerEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager item) => new RxMobileBroadbandSarManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxESimEvents + { + private readonly global::Windows.Networking.NetworkOperators.ESim _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxESimEvents(global::Windows.Networking.NetworkOperators.ESim data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESim sender, object args)> ProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESim sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESim sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProfileChanged += x, x => _data.ProfileChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxESimProfileMetadataEvents + { + private readonly global::Windows.Networking.NetworkOperators.ESimProfileMetadata _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxESimProfileMetadataEvents(global::Windows.Networking.NetworkOperators.ESimProfileMetadata data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxESimWatcherEvents + { + private readonly global::Windows.Networking.NetworkOperators.ESimWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxESimWatcherEvents(global::Windows.Networking.NetworkOperators.ESimWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMobileBroadbandAccountWatcherEvents + { + private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMobileBroadbandAccountWatcherEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)> AccountAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccountAdded += x, x => _data.AccountAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)> AccountRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccountRemoved += x, x => _data.AccountRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args)> AccountUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccountUpdated += x, x => _data.AccountUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMobileBroadbandDeviceServiceDataSessionEvents + { + private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMobileBroadbandDeviceServiceDataSessionEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args)> DataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMobileBroadbandModemEvents + { + private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandModem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMobileBroadbandModemEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandModem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args)> IsInEmergencyCallModeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsInEmergencyCallModeChanged += x, x => _data.IsInEmergencyCallModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMobileBroadbandSarManagerEvents + { + private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMobileBroadbandSarManagerEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args)> TransmissionStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransmissionStateChanged += x, x => _data.TransmissionStateChanged -= x); + } +} + +namespace Windows.Networking.Proximity +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPeerWatcherEvents Events(this global::Windows.Networking.Proximity.PeerWatcher item) => new RxPeerWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProximityDeviceEvents Events(this global::Windows.Networking.Proximity.ProximityDevice item) => new RxProximityDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPeerWatcherEvents + { + private readonly global::Windows.Networking.Proximity.PeerWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPeerWatcherEvents(global::Windows.Networking.Proximity.PeerWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)>(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)>(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)>(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProximityDeviceEvents + { + private readonly global::Windows.Networking.Proximity.ProximityDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProximityDeviceEvents(global::Windows.Networking.Proximity.ProximityDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DeviceArrived => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); + return Handler; + }, x => _data.DeviceArrived += x, x => _data.DeviceArrived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DeviceDeparted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); + return Handler; + }, x => _data.DeviceDeparted += x, x => _data.DeviceDeparted -= x); + } +} + +namespace Windows.Networking.PushNotifications +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPushNotificationChannelEvents Events(this global::Windows.Networking.PushNotifications.PushNotificationChannel item) => new RxPushNotificationChannelEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPushNotificationChannelEvents + { + private readonly global::Windows.Networking.PushNotifications.PushNotificationChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPushNotificationChannelEvents(global::Windows.Networking.PushNotifications.PushNotificationChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args)> PushNotificationReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PushNotificationReceived += x, x => _data.PushNotificationReceived -= x); + } +} + +namespace Windows.Networking.ServiceDiscovery.Dnssd +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDnssdServiceWatcherEvents Events(this global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher item) => new RxDnssdServiceWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDnssdServiceWatcherEvents + { + private readonly global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDnssdServiceWatcherEvents(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args)>(eventHandler => + { + void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } +} + +namespace Windows.Networking.Sockets +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatagramSocketEvents Events(this global::Windows.Networking.Sockets.DatagramSocket item) => new RxDatagramSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIWebSocketEvents Events(this global::Windows.Networking.Sockets.IWebSocket item) => new RxIWebSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMessageWebSocketEvents Events(this global::Windows.Networking.Sockets.MessageWebSocket item) => new RxMessageWebSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxServerMessageWebSocketEvents Events(this global::Windows.Networking.Sockets.ServerMessageWebSocket item) => new RxServerMessageWebSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxServerStreamWebSocketEvents Events(this global::Windows.Networking.Sockets.ServerStreamWebSocket item) => new RxServerStreamWebSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStreamSocketListenerEvents Events(this global::Windows.Networking.Sockets.StreamSocketListener item) => new RxStreamSocketListenerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStreamWebSocketEvents Events(this global::Windows.Networking.Sockets.StreamWebSocket item) => new RxStreamWebSocketEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatagramSocketEvents + { + private readonly global::Windows.Networking.Sockets.DatagramSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatagramSocketEvents(global::Windows.Networking.Sockets.DatagramSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIWebSocketEvents + { + private readonly global::Windows.Networking.Sockets.IWebSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIWebSocketEvents(global::Windows.Networking.Sockets.IWebSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMessageWebSocketEvents + { + private readonly global::Windows.Networking.Sockets.MessageWebSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMessageWebSocketEvents(global::Windows.Networking.Sockets.MessageWebSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)> ServerCustomValidationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxServerMessageWebSocketEvents + { + private readonly global::Windows.Networking.Sockets.ServerMessageWebSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxServerMessageWebSocketEvents(global::Windows.Networking.Sockets.ServerMessageWebSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxServerStreamWebSocketEvents + { + private readonly global::Windows.Networking.Sockets.ServerStreamWebSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxServerStreamWebSocketEvents(global::Windows.Networking.Sockets.ServerStreamWebSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStreamSocketListenerEvents + { + private readonly global::Windows.Networking.Sockets.StreamSocketListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStreamSocketListenerEvents(global::Windows.Networking.Sockets.StreamSocketListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args)> ConnectionReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionReceived += x, x => _data.ConnectionReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStreamWebSocketEvents + { + private readonly global::Windows.Networking.Sockets.StreamWebSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStreamWebSocketEvents(global::Windows.Networking.Sockets.StreamWebSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)> ServerCustomValidationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + } +} + +namespace Windows.Networking.Vpn +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVpnChannelEvents Events(this global::Windows.Networking.Vpn.VpnChannel item) => new RxVpnChannelEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVpnChannelEvents + { + private readonly global::Windows.Networking.Vpn.VpnChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVpnChannelEvents(global::Windows.Networking.Vpn.VpnChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args)> ActivityChange => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActivityChange += x, x => _data.ActivityChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args)> ActivityStateChange => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActivityStateChange += x, x => _data.ActivityStateChange -= x); + } +} + +namespace Windows.Networking.XboxLive +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXboxLiveDeviceAddressEvents Events(this global::Windows.Networking.XboxLive.XboxLiveDeviceAddress item) => new RxXboxLiveDeviceAddressEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXboxLiveEndpointPairEvents Events(this global::Windows.Networking.XboxLive.XboxLiveEndpointPair item) => new RxXboxLiveEndpointPairEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXboxLiveEndpointPairTemplateEvents Events(this global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate item) => new RxXboxLiveEndpointPairTemplateEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXboxLiveDeviceAddressEvents + { + private readonly global::Windows.Networking.XboxLive.XboxLiveDeviceAddress _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXboxLiveDeviceAddressEvents(global::Windows.Networking.XboxLive.XboxLiveDeviceAddress data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.XboxLive.XboxLiveDeviceAddress sender, object args)> SnapshotChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.XboxLive.XboxLiveDeviceAddress sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.XboxLive.XboxLiveDeviceAddress sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SnapshotChanged += x, x => _data.SnapshotChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXboxLiveEndpointPairEvents + { + private readonly global::Windows.Networking.XboxLive.XboxLiveEndpointPair _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXboxLiveEndpointPairEvents(global::Windows.Networking.XboxLive.XboxLiveEndpointPair data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.XboxLive.XboxLiveEndpointPair sender, global::Windows.Networking.XboxLive.XboxLiveEndpointPairStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.XboxLive.XboxLiveEndpointPair sender, global::Windows.Networking.XboxLive.XboxLiveEndpointPairStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.XboxLive.XboxLiveEndpointPair sender, global::Windows.Networking.XboxLive.XboxLiveEndpointPairStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXboxLiveEndpointPairTemplateEvents + { + private readonly global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXboxLiveEndpointPairTemplateEvents(global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate sender, global::Windows.Networking.XboxLive.XboxLiveInboundEndpointPairCreatedEventArgs args)> InboundEndpointPairCreated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate sender, global::Windows.Networking.XboxLive.XboxLiveInboundEndpointPairCreatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate sender, global::Windows.Networking.XboxLive.XboxLiveInboundEndpointPairCreatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InboundEndpointPairCreated += x, x => _data.InboundEndpointPairCreated -= x); + } +} + +namespace Windows.Perception.Spatial +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialAnchorEvents Events(this global::Windows.Perception.Spatial.SpatialAnchor item) => new RxSpatialAnchorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialEntityWatcherEvents Events(this global::Windows.Perception.Spatial.SpatialEntityWatcher item) => new RxSpatialEntityWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialLocatorEvents Events(this global::Windows.Perception.Spatial.SpatialLocator item) => new RxSpatialLocatorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialAnchorEvents + { + private readonly global::Windows.Perception.Spatial.SpatialAnchor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialAnchorEvents(global::Windows.Perception.Spatial.SpatialAnchor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args)> RawCoordinateSystemAdjusted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RawCoordinateSystemAdjusted += x, x => _data.RawCoordinateSystemAdjusted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialEntityWatcherEvents + { + private readonly global::Windows.Perception.Spatial.SpatialEntityWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialEntityWatcherEvents(global::Windows.Perception.Spatial.SpatialEntityWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialLocatorEvents + { + private readonly global::Windows.Perception.Spatial.SpatialLocator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialLocatorEvents(global::Windows.Perception.Spatial.SpatialLocator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialLocator sender, object args)> LocatabilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialLocator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LocatabilityChanged += x, x => _data.LocatabilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args)> PositionalTrackingDeactivating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionalTrackingDeactivating += x, x => _data.PositionalTrackingDeactivating -= x); + } +} + +namespace Windows.Perception.Spatial.Surfaces +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialSurfaceObserverEvents Events(this global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver item) => new RxSpatialSurfaceObserverEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialSurfaceObserverEvents + { + private readonly global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialSurfaceObserverEvents(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args)> ObservedSurfacesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ObservedSurfacesChanged += x, x => _data.ObservedSurfacesChanged -= x); + } +} + +namespace Windows.Phone.Devices.Power +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBatteryEvents Events(this global::Windows.Phone.Devices.Power.Battery item) => new RxBatteryEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBatteryEvents + { + private readonly global::Windows.Phone.Devices.Power.Battery _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBatteryEvents(global::Windows.Phone.Devices.Power.Battery data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemainingChargePercentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.RemainingChargePercentChanged += x, x => _data.RemainingChargePercentChanged -= x); + } +} + +namespace Windows.Phone.Media.Devices +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioRoutingManagerEvents Events(this global::Windows.Phone.Media.Devices.AudioRoutingManager item) => new RxAudioRoutingManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioRoutingManagerEvents + { + private readonly global::Windows.Phone.Media.Devices.AudioRoutingManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioRoutingManagerEvents(global::Windows.Phone.Media.Devices.AudioRoutingManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args)> AudioEndpointChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioEndpointChanged += x, x => _data.AudioEndpointChanged -= x); + } +} + +namespace Windows.Security.Authentication.Web.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebAccountMonitorEvents Events(this global::Windows.Security.Authentication.Web.Core.WebAccountMonitor item) => new RxWebAccountMonitorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebAccountMonitorEvents + { + private readonly global::Windows.Security.Authentication.Web.Core.WebAccountMonitor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebAccountMonitorEvents(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)> AccountPictureUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccountPictureUpdated += x, x => _data.AccountPictureUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args)> DefaultSignInAccountChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args)>(eventHandler => + { + void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DefaultSignInAccountChanged += x, x => _data.DefaultSignInAccountChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace Windows.Security.Authorization.AppCapabilityAccess +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppCapabilityEvents Events(this global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability item) => new RxAppCapabilityEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppCapabilityEvents + { + private readonly global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppCapabilityEvents(global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability sender, global::Windows.Security.Authorization.AppCapabilityAccess.AppCapabilityAccessChangedEventArgs args)> AccessChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability sender, global::Windows.Security.Authorization.AppCapabilityAccess.AppCapabilityAccessChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability sender, global::Windows.Security.Authorization.AppCapabilityAccess.AppCapabilityAccessChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessChanged += x, x => _data.AccessChanged -= x); + } +} + +namespace Windows.Security.Credentials +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordCredentialPropertyStoreEvents Events(this global::Windows.Security.Credentials.PasswordCredentialPropertyStore item) => new RxPasswordCredentialPropertyStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordCredentialPropertyStoreEvents + { + private readonly global::Windows.Security.Credentials.PasswordCredentialPropertyStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordCredentialPropertyStoreEvents(global::Windows.Security.Credentials.PasswordCredentialPropertyStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } +} + +namespace Windows.Security.DataProtection +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserDataProtectionManagerEvents Events(this global::Windows.Security.DataProtection.UserDataProtectionManager item) => new RxUserDataProtectionManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserDataProtectionManagerEvents + { + private readonly global::Windows.Security.DataProtection.UserDataProtectionManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserDataProtectionManagerEvents(global::Windows.Security.DataProtection.UserDataProtectionManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.DataProtection.UserDataProtectionManager sender, global::Windows.Security.DataProtection.UserDataAvailabilityStateChangedEventArgs args)> DataAvailabilityStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.DataProtection.UserDataProtectionManager sender, global::Windows.Security.DataProtection.UserDataAvailabilityStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Security.DataProtection.UserDataProtectionManager sender, global::Windows.Security.DataProtection.UserDataAvailabilityStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataAvailabilityStateChanged += x, x => _data.DataAvailabilityStateChanged -= x); + } +} + +namespace Windows.Services.Maps.Guidance +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGuidanceNavigatorEvents Events(this global::Windows.Services.Maps.Guidance.GuidanceNavigator item) => new RxGuidanceNavigatorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGuidanceNavigatorEvents + { + private readonly global::Windows.Services.Maps.Guidance.GuidanceNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGuidanceNavigatorEvents(global::Windows.Services.Maps.Guidance.GuidanceNavigator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceAudioNotificationRequestedEventArgs args)> AudioNotificationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceAudioNotificationRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceAudioNotificationRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioNotificationRequested += x, x => _data.AudioNotificationRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)> DestinationReached => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DestinationReached += x, x => _data.DestinationReached -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs args)> GuidanceUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GuidanceUpdated += x, x => _data.GuidanceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceReroutedEventArgs args)> Rerouted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceReroutedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceReroutedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Rerouted += x, x => _data.Rerouted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)> RerouteFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RerouteFailed += x, x => _data.RerouteFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)> Rerouting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Rerouting += x, x => _data.Rerouting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)> UserLocationLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserLocationLost += x, x => _data.UserLocationLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)> UserLocationRestored => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserLocationRestored += x, x => _data.UserLocationRestored -= x); + } +} + +namespace Windows.Services.Maps.OfflineMaps +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxOfflineMapPackageEvents Events(this global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage item) => new RxOfflineMapPackageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxOfflineMapPackageEvents + { + private readonly global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxOfflineMapPackageEvents(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } +} + +namespace Windows.Services.Store +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStoreContextEvents Events(this global::Windows.Services.Store.StoreContext item) => new RxStoreContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorePackageLicenseEvents Events(this global::Windows.Services.Store.StorePackageLicense item) => new RxStorePackageLicenseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStoreQueueItemEvents Events(this global::Windows.Services.Store.StoreQueueItem item) => new RxStoreQueueItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStoreContextEvents + { + private readonly global::Windows.Services.Store.StoreContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStoreContextEvents(global::Windows.Services.Store.StoreContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Store.StoreContext sender, object args)> OfflineLicensesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Store.StoreContext sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Store.StoreContext sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OfflineLicensesChanged += x, x => _data.OfflineLicensesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorePackageLicenseEvents + { + private readonly global::Windows.Services.Store.StorePackageLicense _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorePackageLicenseEvents(global::Windows.Services.Store.StorePackageLicense data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Store.StorePackageLicense sender, object args)> LicenseLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Store.StorePackageLicense sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Store.StorePackageLicense sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LicenseLost += x, x => _data.LicenseLost -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStoreQueueItemEvents + { + private readonly global::Windows.Services.Store.StoreQueueItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStoreQueueItemEvents(global::Windows.Services.Store.StoreQueueItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Store.StoreQueueItem sender, global::Windows.Services.Store.StoreQueueItemCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Store.StoreQueueItem sender, global::Windows.Services.Store.StoreQueueItemCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.Store.StoreQueueItem sender, global::Windows.Services.Store.StoreQueueItemCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Store.StoreQueueItem sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Store.StoreQueueItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Store.StoreQueueItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } +} + +namespace Windows.Services.TargetedContent +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTargetedContentSubscriptionEvents Events(this global::Windows.Services.TargetedContent.TargetedContentSubscription item) => new RxTargetedContentSubscriptionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTargetedContentSubscriptionEvents + { + private readonly global::Windows.Services.TargetedContent.TargetedContentSubscription _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTargetedContentSubscriptionEvents(global::Windows.Services.TargetedContent.TargetedContentSubscription data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentAvailabilityChangedEventArgs args)> AvailabilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentAvailabilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentAvailabilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentChangedEventArgs args)> ContentChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentChanged += x, x => _data.ContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace Windows.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationDataEvents Events(this global::Windows.Storage.ApplicationData item) => new RxApplicationDataEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationDataCompositeValueEvents Events(this global::Windows.Storage.ApplicationDataCompositeValue item) => new RxApplicationDataCompositeValueEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationDataContainerSettingsEvents Events(this global::Windows.Storage.ApplicationDataContainerSettings item) => new RxApplicationDataContainerSettingsEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorageLibraryEvents Events(this global::Windows.Storage.StorageLibrary item) => new RxStorageLibraryEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationDataEvents + { + private readonly global::Windows.Storage.ApplicationData _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationDataEvents(global::Windows.Storage.ApplicationData data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.ApplicationData sender, object args)> DataChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.ApplicationData sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.ApplicationData sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationDataCompositeValueEvents + { + private readonly global::Windows.Storage.ApplicationDataCompositeValue _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationDataCompositeValueEvents(global::Windows.Storage.ApplicationDataCompositeValue data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationDataContainerSettingsEvents + { + private readonly global::Windows.Storage.ApplicationDataContainerSettings _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationDataContainerSettingsEvents(global::Windows.Storage.ApplicationDataContainerSettings data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorageLibraryEvents + { + private readonly global::Windows.Storage.StorageLibrary _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorageLibraryEvents(global::Windows.Storage.StorageLibrary data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.StorageLibrary sender, object args)> DefinitionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.StorageLibrary sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.StorageLibrary sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DefinitionChanged += x, x => _data.DefinitionChanged -= x); + } +} + +namespace Windows.Storage.AccessCache +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorageItemMostRecentlyUsedListEvents Events(this global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList item) => new RxStorageItemMostRecentlyUsedListEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorageItemMostRecentlyUsedListEvents + { + private readonly global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorageItemMostRecentlyUsedListEvents(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args)> ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + } +} + +namespace Windows.Storage.BulkAccess +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileInformationEvents Events(this global::Windows.Storage.BulkAccess.FileInformation item) => new RxFileInformationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderInformationEvents Events(this global::Windows.Storage.BulkAccess.FolderInformation item) => new RxFolderInformationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIStorageItemInformationEvents Events(this global::Windows.Storage.BulkAccess.IStorageItemInformation item) => new RxIStorageItemInformationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileInformationEvents + { + private readonly global::Windows.Storage.BulkAccess.FileInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileInformationEvents(global::Windows.Storage.BulkAccess.FileInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> PropertiesUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> ThumbnailUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderInformationEvents + { + private readonly global::Windows.Storage.BulkAccess.FolderInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderInformationEvents(global::Windows.Storage.BulkAccess.FolderInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> PropertiesUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> ThumbnailUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIStorageItemInformationEvents + { + private readonly global::Windows.Storage.BulkAccess.IStorageItemInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIStorageItemInformationEvents(global::Windows.Storage.BulkAccess.IStorageItemInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> PropertiesUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> ThumbnailUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + } +} + +namespace Windows.Storage.Pickers.Provider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileOpenPickerUIEvents Events(this global::Windows.Storage.Pickers.Provider.FileOpenPickerUI item) => new RxFileOpenPickerUIEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileSavePickerUIEvents Events(this global::Windows.Storage.Pickers.Provider.FileSavePickerUI item) => new RxFileSavePickerUIEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileOpenPickerUIEvents + { + private readonly global::Windows.Storage.Pickers.Provider.FileOpenPickerUI _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileOpenPickerUIEvents(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args)> FileRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FileRemoved += x, x => _data.FileRemoved -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileSavePickerUIEvents + { + private readonly global::Windows.Storage.Pickers.Provider.FileSavePickerUI _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileSavePickerUIEvents(global::Windows.Storage.Pickers.Provider.FileSavePickerUI data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args)> FileNameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FileNameChanged += x, x => _data.FileNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args)> TargetFileRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TargetFileRequested += x, x => _data.TargetFileRequested -= x); + } +} + +namespace Windows.Storage.Provider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCachedFileUpdaterUIEvents Events(this global::Windows.Storage.Provider.CachedFileUpdaterUI item) => new RxCachedFileUpdaterUIEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCachedFileUpdaterUIEvents + { + private readonly global::Windows.Storage.Provider.CachedFileUpdaterUI _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCachedFileUpdaterUIEvents(global::Windows.Storage.Provider.CachedFileUpdaterUI data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args)> FileUpdateRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FileUpdateRequested += x, x => _data.FileUpdateRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args)> UIRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UIRequested += x, x => _data.UIRequested -= x); + } +} + +namespace Windows.Storage.Search +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIStorageQueryResultBaseEvents Events(this global::Windows.Storage.Search.IStorageQueryResultBase item) => new RxIStorageQueryResultBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorageFileQueryResultEvents Events(this global::Windows.Storage.Search.StorageFileQueryResult item) => new RxStorageFileQueryResultEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorageFolderQueryResultEvents Events(this global::Windows.Storage.Search.StorageFolderQueryResult item) => new RxStorageFolderQueryResultEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorageItemQueryResultEvents Events(this global::Windows.Storage.Search.StorageItemQueryResult item) => new RxStorageItemQueryResultEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIStorageQueryResultBaseEvents + { + private readonly global::Windows.Storage.Search.IStorageQueryResultBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIStorageQueryResultBaseEvents(global::Windows.Storage.Search.IStorageQueryResultBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorageFileQueryResultEvents + { + private readonly global::Windows.Storage.Search.StorageFileQueryResult _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorageFileQueryResultEvents(global::Windows.Storage.Search.StorageFileQueryResult data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorageFolderQueryResultEvents + { + private readonly global::Windows.Storage.Search.StorageFolderQueryResult _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorageFolderQueryResultEvents(global::Windows.Storage.Search.StorageFolderQueryResult data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorageItemQueryResultEvents + { + private readonly global::Windows.Storage.Search.StorageItemQueryResult _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorageItemQueryResultEvents(global::Windows.Storage.Search.StorageItemQueryResult data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + } +} + +namespace Windows.System +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppDiagnosticInfoWatcherEvents Events(this global::Windows.System.AppDiagnosticInfoWatcher item) => new RxAppDiagnosticInfoWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppResourceGroupInfoWatcherEvents Events(this global::Windows.System.AppResourceGroupInfoWatcher item) => new RxAppResourceGroupInfoWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherQueueEvents Events(this global::Windows.System.DispatcherQueue item) => new RxDispatcherQueueEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherQueueTimerEvents Events(this global::Windows.System.DispatcherQueueTimer item) => new RxDispatcherQueueTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserWatcherEvents Events(this global::Windows.System.UserWatcher item) => new RxUserWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppDiagnosticInfoWatcherEvents + { + private readonly global::Windows.System.AppDiagnosticInfoWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppDiagnosticInfoWatcherEvents(global::Windows.System.AppDiagnosticInfoWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppResourceGroupInfoWatcherEvents + { + private readonly global::Windows.System.AppResourceGroupInfoWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppResourceGroupInfoWatcherEvents(global::Windows.System.AppResourceGroupInfoWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args)> ExecutionStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ExecutionStateChanged += x, x => _data.ExecutionStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherQueueEvents + { + private readonly global::Windows.System.DispatcherQueue _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherQueueEvents(global::Windows.System.DispatcherQueue data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.DispatcherQueue sender, object args)> ShutdownCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.DispatcherQueue sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.DispatcherQueue sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShutdownCompleted += x, x => _data.ShutdownCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args)> ShutdownStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShutdownStarting += x, x => _data.ShutdownStarting -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherQueueTimerEvents + { + private readonly global::Windows.System.DispatcherQueueTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherQueueTimerEvents(global::Windows.System.DispatcherQueueTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.DispatcherQueueTimer sender, object args)> Tick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.DispatcherQueueTimer sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.DispatcherQueueTimer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserWatcherEvents + { + private readonly global::Windows.System.UserWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserWatcherEvents(global::Windows.System.UserWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> AuthenticationStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AuthenticationStatusChanged += x, x => _data.AuthenticationStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args)> AuthenticationStatusChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AuthenticationStatusChanging += x, x => _data.AuthenticationStatusChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace Windows.System.Diagnostics.DevicePortal +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDevicePortalConnectionEvents Events(this global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection item) => new RxDevicePortalConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDevicePortalConnectionEvents + { + private readonly global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDevicePortalConnectionEvents(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args)> RequestReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + } +} + +namespace Windows.System.Preview +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTwoPanelHingedDevicePosturePreviewEvents Events(this global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview item) => new RxTwoPanelHingedDevicePosturePreviewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTwoPanelHingedDevicePosturePreviewEvents + { + private readonly global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTwoPanelHingedDevicePosturePreviewEvents(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args)> PostureChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PostureChanged += x, x => _data.PostureChanged -= x); + } +} + +namespace Windows.System.RemoteSystems +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSession item) => new RxRemoteSystemSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionControllerEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionController item) => new RxRemoteSystemSessionControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionInvitationListenerEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener item) => new RxRemoteSystemSessionInvitationListenerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionMessageChannelEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel item) => new RxRemoteSystemSessionMessageChannelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionParticipantWatcherEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher item) => new RxRemoteSystemSessionParticipantWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionWatcherEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher item) => new RxRemoteSystemSessionWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemWatcherEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemWatcher item) => new RxRemoteSystemWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionEvents(global::Windows.System.RemoteSystems.RemoteSystemSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args)> Disconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Disconnected += x, x => _data.Disconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionControllerEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionControllerEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args)> JoinRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.JoinRequested += x, x => _data.JoinRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionInvitationListenerEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionInvitationListenerEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args)> InvitationReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InvitationReceived += x, x => _data.InvitationReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionMessageChannelEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionMessageChannelEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args)> ValueSetReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValueSetReceived += x, x => _data.ValueSetReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionParticipantWatcherEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionParticipantWatcherEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionWatcherEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionWatcherEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemWatcherEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemWatcherEvents(global::Windows.System.RemoteSystems.RemoteSystemWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args)> RemoteSystemAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RemoteSystemAdded += x, x => _data.RemoteSystemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args)> RemoteSystemRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RemoteSystemRemoved += x, x => _data.RemoteSystemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args)> RemoteSystemUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RemoteSystemUpdated += x, x => _data.RemoteSystemUpdated -= x); + } +} + +namespace Windows.UI.Accessibility +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScreenReaderServiceEvents Events(this global::Windows.UI.Accessibility.ScreenReaderService item) => new RxScreenReaderServiceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScreenReaderServiceEvents + { + private readonly global::Windows.UI.Accessibility.ScreenReaderService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScreenReaderServiceEvents(global::Windows.UI.Accessibility.ScreenReaderService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args)> ScreenReaderPositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScreenReaderPositionChanged += x, x => _data.ScreenReaderPositionChanged -= x); + } +} + +namespace Windows.UI.ApplicationSettings +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAccountsSettingsPaneEvents Events(this global::Windows.UI.ApplicationSettings.AccountsSettingsPane item) => new RxAccountsSettingsPaneEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSettingsPaneEvents Events(this global::Windows.UI.ApplicationSettings.SettingsPane item) => new RxSettingsPaneEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAccountsSettingsPaneEvents + { + private readonly global::Windows.UI.ApplicationSettings.AccountsSettingsPane _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAccountsSettingsPaneEvents(global::Windows.UI.ApplicationSettings.AccountsSettingsPane data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args)> AccountCommandsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccountCommandsRequested += x, x => _data.AccountCommandsRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSettingsPaneEvents + { + private readonly global::Windows.UI.ApplicationSettings.SettingsPane _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSettingsPaneEvents(global::Windows.UI.ApplicationSettings.SettingsPane data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ApplicationSettings.SettingsPane sender, global::Windows.UI.ApplicationSettings.SettingsPaneCommandsRequestedEventArgs args)> CommandsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ApplicationSettings.SettingsPane sender, global::Windows.UI.ApplicationSettings.SettingsPaneCommandsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ApplicationSettings.SettingsPane sender, global::Windows.UI.ApplicationSettings.SettingsPaneCommandsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CommandsRequested += x, x => _data.CommandsRequested -= x); + } +} + +namespace Windows.UI.Composition +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompositionCapabilitiesEvents Events(this global::Windows.UI.Composition.CompositionCapabilities item) => new RxCompositionCapabilitiesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompositionCommitBatchEvents Events(this global::Windows.UI.Composition.CompositionCommitBatch item) => new RxCompositionCommitBatchEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompositionGraphicsDeviceEvents Events(this global::Windows.UI.Composition.CompositionGraphicsDevice item) => new RxCompositionGraphicsDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompositionScopedBatchEvents Events(this global::Windows.UI.Composition.CompositionScopedBatch item) => new RxCompositionScopedBatchEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompositionCapabilitiesEvents + { + private readonly global::Windows.UI.Composition.CompositionCapabilities _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompositionCapabilitiesEvents(global::Windows.UI.Composition.CompositionCapabilities data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Composition.CompositionCapabilities sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Composition.CompositionCapabilities sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Composition.CompositionCapabilities sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompositionCommitBatchEvents + { + private readonly global::Windows.UI.Composition.CompositionCommitBatch _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompositionCommitBatchEvents(global::Windows.UI.Composition.CompositionCommitBatch data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompositionGraphicsDeviceEvents + { + private readonly global::Windows.UI.Composition.CompositionGraphicsDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompositionGraphicsDeviceEvents(global::Windows.UI.Composition.CompositionGraphicsDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args)> RenderingDeviceReplaced => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RenderingDeviceReplaced += x, x => _data.RenderingDeviceReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompositionScopedBatchEvents + { + private readonly global::Windows.UI.Composition.CompositionScopedBatch _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompositionScopedBatchEvents(global::Windows.UI.Composition.CompositionScopedBatch data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } +} + +namespace Windows.UI.Composition.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompositorControllerEvents Events(this global::Windows.UI.Composition.Core.CompositorController item) => new RxCompositorControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompositorControllerEvents + { + private readonly global::Windows.UI.Composition.Core.CompositorController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompositorControllerEvents(global::Windows.UI.Composition.Core.CompositorController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Composition.Core.CompositorController sender, object args)> CommitNeeded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Composition.Core.CompositorController sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Composition.Core.CompositorController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CommitNeeded += x, x => _data.CommitNeeded -= x); + } +} + +namespace Windows.UI.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreAcceleratorKeysEvents Events(this global::Windows.UI.Core.CoreAcceleratorKeys item) => new RxCoreAcceleratorKeysEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreComponentInputSourceEvents Events(this global::Windows.UI.Core.CoreComponentInputSource item) => new RxCoreComponentInputSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreDispatcherEvents Events(this global::Windows.UI.Core.CoreDispatcher item) => new RxCoreDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreIndependentInputSourceEvents Events(this global::Windows.UI.Core.CoreIndependentInputSource item) => new RxCoreIndependentInputSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreWindowEvents Events(this global::Windows.UI.Core.CoreWindow item) => new RxCoreWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreWindowDialogEvents Events(this global::Windows.UI.Core.CoreWindowDialog item) => new RxCoreWindowDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreWindowFlyoutEvents Events(this global::Windows.UI.Core.CoreWindowFlyout item) => new RxCoreWindowFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICoreAcceleratorKeysEvents Events(this global::Windows.UI.Core.ICoreAcceleratorKeys item) => new RxICoreAcceleratorKeysEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICoreInputSourceBaseEvents Events(this global::Windows.UI.Core.ICoreInputSourceBase item) => new RxICoreInputSourceBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICorePointerInputSourceEvents Events(this global::Windows.UI.Core.ICorePointerInputSource item) => new RxICorePointerInputSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICorePointerRedirectorEvents Events(this global::Windows.UI.Core.ICorePointerRedirector item) => new RxICorePointerRedirectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICoreWindowEvents Events(this global::Windows.UI.Core.ICoreWindow item) => new RxICoreWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSystemNavigationManagerEvents Events(this global::Windows.UI.Core.SystemNavigationManager item) => new RxSystemNavigationManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreAcceleratorKeysEvents + { + private readonly global::Windows.UI.Core.CoreAcceleratorKeys _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreAcceleratorKeysEvents(global::Windows.UI.Core.CoreAcceleratorKeys data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)> AcceleratorKeyActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreComponentInputSourceEvents + { + private readonly global::Windows.UI.Core.CoreComponentInputSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreComponentInputSourceEvents(global::Windows.UI.Core.CoreComponentInputSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.CharacterReceivedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)> ClosestInteractiveBoundsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.CoreWindowEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.InputEnabledEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.KeyEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.KeyEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.CoreWindowEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchHitTesting => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.TouchHitTestingEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreDispatcherEvents + { + private readonly global::Windows.UI.Core.CoreDispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreDispatcherEvents(global::Windows.UI.Core.CoreDispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)> AcceleratorKeyActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreIndependentInputSourceEvents + { + private readonly global::Windows.UI.Core.CoreIndependentInputSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreIndependentInputSourceEvents(global::Windows.UI.Core.CoreIndependentInputSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.InputEnabledEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreWindowEvents + { + private readonly global::Windows.UI.Core.CoreWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreWindowEvents(global::Windows.UI.Core.CoreWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)> AutomationProviderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)> CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)> ClosestInteractiveBoundsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)> InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyDown => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyUp => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedAway => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedTo => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, object args)> ResizeCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResizeCompleted += x, x => _data.ResizeCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, object args)> ResizeStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResizeStarted += x, x => _data.ResizeStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)> SizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)> TouchHitTesting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)> VisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreWindowDialogEvents + { + private readonly global::Windows.UI.Core.CoreWindowDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreWindowDialogEvents(global::Windows.UI.Core.CoreWindowDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args)> Showing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Showing += x, x => _data.Showing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreWindowFlyoutEvents + { + private readonly global::Windows.UI.Core.CoreWindowFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreWindowFlyoutEvents(global::Windows.UI.Core.CoreWindowFlyout data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args)> Showing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Showing += x, x => _data.Showing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICoreAcceleratorKeysEvents + { + private readonly global::Windows.UI.Core.ICoreAcceleratorKeys _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICoreAcceleratorKeysEvents(global::Windows.UI.Core.ICoreAcceleratorKeys data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)> AcceleratorKeyActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICoreInputSourceBaseEvents + { + private readonly global::Windows.UI.Core.ICoreInputSourceBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICoreInputSourceBaseEvents(global::Windows.UI.Core.ICoreInputSourceBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.InputEnabledEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICorePointerInputSourceEvents + { + private readonly global::Windows.UI.Core.ICorePointerInputSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICorePointerInputSourceEvents(global::Windows.UI.Core.ICorePointerInputSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICorePointerRedirectorEvents + { + private readonly global::Windows.UI.Core.ICorePointerRedirector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICorePointerRedirectorEvents(global::Windows.UI.Core.ICorePointerRedirector data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedAway => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedTo => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICoreWindowEvents + { + private readonly global::Windows.UI.Core.ICoreWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICoreWindowEvents(global::Windows.UI.Core.ICoreWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)> AutomationProviderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)> CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)> InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyDown => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyUp => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)> SizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)> TouchHitTesting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)> VisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSystemNavigationManagerEvents + { + private readonly global::Windows.UI.Core.SystemNavigationManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSystemNavigationManagerEvents(global::Windows.UI.Core.SystemNavigationManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.BackRequestedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.BackRequestedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); + } +} + +namespace Windows.UI.Core.Preview +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSystemNavigationManagerPreviewEvents Events(this global::Windows.UI.Core.Preview.SystemNavigationManagerPreview item) => new RxSystemNavigationManagerPreviewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSystemNavigationManagerPreviewEvents + { + private readonly global::Windows.UI.Core.Preview.SystemNavigationManagerPreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSystemNavigationManagerPreviewEvents(global::Windows.UI.Core.Preview.SystemNavigationManagerPreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.Preview.SystemNavigationCloseRequestedPreviewEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.Preview.SystemNavigationCloseRequestedPreviewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + } +} + +namespace Windows.UI.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEdgeGestureEvents Events(this global::Windows.UI.Input.EdgeGesture item) => new RxEdgeGestureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGestureRecognizerEvents Events(this global::Windows.UI.Input.GestureRecognizer item) => new RxGestureRecognizerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputActivationListenerEvents Events(this global::Windows.UI.Input.InputActivationListener item) => new RxInputActivationListenerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxKeyboardDeliveryInterceptorEvents Events(this global::Windows.UI.Input.KeyboardDeliveryInterceptor item) => new RxKeyboardDeliveryInterceptorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadialControllerEvents Events(this global::Windows.UI.Input.RadialController item) => new RxRadialControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadialControllerMenuItemEvents Events(this global::Windows.UI.Input.RadialControllerMenuItem item) => new RxRadialControllerMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSystemButtonEventControllerEvents Events(this global::Windows.UI.Input.SystemButtonEventController item) => new RxSystemButtonEventControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEdgeGestureEvents + { + private readonly global::Windows.UI.Input.EdgeGesture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEdgeGestureEvents(global::Windows.UI.Input.EdgeGesture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)> Canceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Canceled += x, x => _data.Canceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)> Starting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Starting += x, x => _data.Starting -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGestureRecognizerEvents + { + private readonly global::Windows.UI.Input.GestureRecognizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGestureRecognizerEvents(global::Windows.UI.Input.GestureRecognizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args)> CrossSliding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CrossSliding += x, x => _data.CrossSliding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args)> Dragging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Dragging += x, x => _data.Dragging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args)> Holding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Holding += x, x => _data.Holding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args)> ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args)> ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args)> ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args)> ManipulationUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args)> RightTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args)> Tapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Tapped += x, x => _data.Tapped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputActivationListenerEvents + { + private readonly global::Windows.UI.Input.InputActivationListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputActivationListenerEvents(global::Windows.UI.Input.InputActivationListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.InputActivationListener sender, global::Windows.UI.Input.InputActivationListenerActivationChangedEventArgs args)> InputActivationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.InputActivationListener sender, global::Windows.UI.Input.InputActivationListenerActivationChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.InputActivationListener sender, global::Windows.UI.Input.InputActivationListenerActivationChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InputActivationChanged += x, x => _data.InputActivationChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxKeyboardDeliveryInterceptorEvents + { + private readonly global::Windows.UI.Input.KeyboardDeliveryInterceptor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxKeyboardDeliveryInterceptorEvents(global::Windows.UI.Input.KeyboardDeliveryInterceptor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)> KeyDown => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)> KeyUp => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadialControllerEvents + { + private readonly global::Windows.UI.Input.RadialController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadialControllerEvents(global::Windows.UI.Input.RadialController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args)> ButtonClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ButtonClicked += x, x => _data.ButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args)> ButtonHolding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ButtonHolding += x, x => _data.ButtonHolding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args)> ButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args)> ButtonReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ButtonReleased += x, x => _data.ButtonReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args)> ControlAcquired => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ControlAcquired += x, x => _data.ControlAcquired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, object args)> ControlLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args)> RotationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RotationChanged += x, x => _data.RotationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args)> ScreenContactContinued => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScreenContactContinued += x, x => _data.ScreenContactContinued -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, object args)> ScreenContactEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScreenContactEnded += x, x => _data.ScreenContactEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args)> ScreenContactStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScreenContactStarted += x, x => _data.ScreenContactStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadialControllerMenuItemEvents + { + private readonly global::Windows.UI.Input.RadialControllerMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadialControllerMenuItemEvents(global::Windows.UI.Input.RadialControllerMenuItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialControllerMenuItem sender, object args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialControllerMenuItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialControllerMenuItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Invoked += x, x => _data.Invoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSystemButtonEventControllerEvents + { + private readonly global::Windows.UI.Input.SystemButtonEventController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSystemButtonEventControllerEvents(global::Windows.UI.Input.SystemButtonEventController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args)> SystemFunctionButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemFunctionButtonPressed += x, x => _data.SystemFunctionButtonPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args)> SystemFunctionButtonReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemFunctionButtonReleased += x, x => _data.SystemFunctionButtonReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockChangedEventArgs args)> SystemFunctionLockChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemFunctionLockChanged += x, x => _data.SystemFunctionLockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockIndicatorChangedEventArgs args)> SystemFunctionLockIndicatorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockIndicatorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockIndicatorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemFunctionLockIndicatorChanged += x, x => _data.SystemFunctionLockIndicatorChanged -= x); + } +} + +namespace Windows.UI.Input.Inking +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkPresenterEvents Events(this global::Windows.UI.Input.Inking.InkPresenter item) => new RxInkPresenterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkStrokeInputEvents Events(this global::Windows.UI.Input.Inking.InkStrokeInput item) => new RxInkStrokeInputEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkUnprocessedInputEvents Events(this global::Windows.UI.Input.Inking.InkUnprocessedInput item) => new RxInkUnprocessedInputEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkPresenterEvents + { + private readonly global::Windows.UI.Input.Inking.InkPresenter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkPresenterEvents(global::Windows.UI.Input.Inking.InkPresenter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args)> StrokesCollected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokesCollected += x, x => _data.StrokesCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args)> StrokesErased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokesErased += x, x => _data.StrokesErased -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkStrokeInputEvents + { + private readonly global::Windows.UI.Input.Inking.InkStrokeInput _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkStrokeInputEvents(global::Windows.UI.Input.Inking.InkStrokeInput data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokeCanceled += x, x => _data.StrokeCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeContinued => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokeContinued += x, x => _data.StrokeContinued -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokeEnded += x, x => _data.StrokeEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokeStarted += x, x => _data.StrokeStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkUnprocessedInputEvents + { + private readonly global::Windows.UI.Input.Inking.InkUnprocessedInput _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkUnprocessedInputEvents(global::Windows.UI.Input.Inking.InkUnprocessedInput data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerHovered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerHovered += x, x => _data.PointerHovered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + } +} + +namespace Windows.UI.Input.Inking.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreInkIndependentInputSourceEvents Events(this global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource item) => new RxCoreInkIndependentInputSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreWetStrokeUpdateSourceEvents Events(this global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource item) => new RxCoreWetStrokeUpdateSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreInkIndependentInputSourceEvents + { + private readonly global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreInkIndependentInputSourceEvents(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntering => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerEntering += x, x => _data.PointerEntering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExiting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerExiting += x, x => _data.PointerExiting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerHovering => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerHovering += x, x => _data.PointerHovering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoving => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerMoving += x, x => _data.PointerMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerPressing += x, x => _data.PointerPressing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleasing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerReleasing += x, x => _data.PointerReleasing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreWetStrokeUpdateSourceEvents + { + private readonly global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreWetStrokeUpdateSourceEvents(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WetStrokeCanceled += x, x => _data.WetStrokeCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WetStrokeCompleted += x, x => _data.WetStrokeCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeContinuing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WetStrokeContinuing += x, x => _data.WetStrokeContinuing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WetStrokeStarting += x, x => _data.WetStrokeStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeStopping => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WetStrokeStopping += x, x => _data.WetStrokeStopping -= x); + } +} + +namespace Windows.UI.Input.Spatial +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialGestureRecognizerEvents Events(this global::Windows.UI.Input.Spatial.SpatialGestureRecognizer item) => new RxSpatialGestureRecognizerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialInteractionManagerEvents Events(this global::Windows.UI.Input.Spatial.SpatialInteractionManager item) => new RxSpatialInteractionManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialGestureRecognizerEvents + { + private readonly global::Windows.UI.Input.Spatial.SpatialGestureRecognizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialGestureRecognizerEvents(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args)> HoldCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HoldCanceled += x, x => _data.HoldCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args)> HoldCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HoldCompleted += x, x => _data.HoldCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args)> HoldStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HoldStarted += x, x => _data.HoldStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args)> ManipulationCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationCanceled += x, x => _data.ManipulationCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args)> ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args)> ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args)> ManipulationUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args)> NavigationCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCanceled += x, x => _data.NavigationCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args)> NavigationStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationStarted += x, x => _data.NavigationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args)> NavigationUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationUpdated += x, x => _data.NavigationUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args)> RecognitionEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RecognitionEnded += x, x => _data.RecognitionEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args)> RecognitionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RecognitionStarted += x, x => _data.RecognitionStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args)> Tapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Tapped += x, x => _data.Tapped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialInteractionManagerEvents + { + private readonly global::Windows.UI.Input.Spatial.SpatialInteractionManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialInteractionManagerEvents(global::Windows.UI.Input.Spatial.SpatialInteractionManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args)> InteractionDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InteractionDetected += x, x => _data.InteractionDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceDetected += x, x => _data.SourceDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceLost += x, x => _data.SourceLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourcePressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourcePressed += x, x => _data.SourcePressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceReleased += x, x => _data.SourceReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + } +} + +namespace Windows.UI.Notifications +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToastNotificationEvents Events(this global::Windows.UI.Notifications.ToastNotification item) => new RxToastNotificationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToastNotifierEvents Events(this global::Windows.UI.Notifications.ToastNotifier item) => new RxToastNotifierEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToastNotificationEvents + { + private readonly global::Windows.UI.Notifications.ToastNotification _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToastNotificationEvents(global::Windows.UI.Notifications.ToastNotification data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotification sender, object args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotification sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Notifications.ToastNotification sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args)> Dismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args)> Failed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToastNotifierEvents + { + private readonly global::Windows.UI.Notifications.ToastNotifier _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToastNotifierEvents(global::Windows.UI.Notifications.ToastNotifier data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args)> ScheduledToastNotificationShowing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScheduledToastNotificationShowing += x, x => _data.ScheduledToastNotificationShowing -= x); + } +} + +namespace Windows.UI.Notifications.Management +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserNotificationListenerEvents Events(this global::Windows.UI.Notifications.Management.UserNotificationListener item) => new RxUserNotificationListenerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserNotificationListenerEvents + { + private readonly global::Windows.UI.Notifications.Management.UserNotificationListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserNotificationListenerEvents(global::Windows.UI.Notifications.Management.UserNotificationListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args)> NotificationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NotificationChanged += x, x => _data.NotificationChanged -= x); + } +} + +namespace Windows.UI.StartScreen +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSecondaryTileEvents Events(this global::Windows.UI.StartScreen.SecondaryTile item) => new RxSecondaryTileEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSecondaryTileEvents + { + private readonly global::Windows.UI.StartScreen.SecondaryTile _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSecondaryTileEvents(global::Windows.UI.StartScreen.SecondaryTile data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args)> VisualElementsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisualElementsRequested += x, x => _data.VisualElementsRequested -= x); + } +} + +namespace Windows.UI.Text.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreTextEditContextEvents Events(this global::Windows.UI.Text.Core.CoreTextEditContext item) => new RxCoreTextEditContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreTextServicesManagerEvents Events(this global::Windows.UI.Text.Core.CoreTextServicesManager item) => new RxCoreTextServicesManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreTextEditContextEvents + { + private readonly global::Windows.UI.Text.Core.CoreTextEditContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreTextEditContextEvents(global::Windows.UI.Text.Core.CoreTextEditContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args)> CompositionCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CompositionCompleted += x, x => _data.CompositionCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args)> CompositionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CompositionStarted += x, x => _data.CompositionStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)> FocusRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FocusRemoved += x, x => _data.FocusRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args)> FormatUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FormatUpdating += x, x => _data.FormatUpdating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args)> LayoutRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LayoutRequested += x, x => _data.LayoutRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)> NotifyFocusLeaveCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NotifyFocusLeaveCompleted += x, x => _data.NotifyFocusLeaveCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args)> SelectionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionRequested += x, x => _data.SelectionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args)> SelectionUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionUpdating += x, x => _data.SelectionUpdating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args)> TextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextRequested += x, x => _data.TextRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args)> TextUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextUpdating += x, x => _data.TextUpdating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreTextServicesManagerEvents + { + private readonly global::Windows.UI.Text.Core.CoreTextServicesManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreTextServicesManagerEvents(global::Windows.UI.Text.Core.CoreTextServicesManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args)> InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + } +} + +namespace Windows.UI.ViewManagement +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAccessibilitySettingsEvents Events(this global::Windows.UI.ViewManagement.AccessibilitySettings item) => new RxAccessibilitySettingsEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationViewEvents Events(this global::Windows.UI.ViewManagement.ApplicationView item) => new RxApplicationViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputPaneEvents Events(this global::Windows.UI.ViewManagement.InputPane item) => new RxInputPaneEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::Windows.UI.ViewManagement.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUISettingsEvents Events(this global::Windows.UI.ViewManagement.UISettings item) => new RxUISettingsEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAccessibilitySettingsEvents + { + private readonly global::Windows.UI.ViewManagement.AccessibilitySettings _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAccessibilitySettingsEvents(global::Windows.UI.ViewManagement.AccessibilitySettings data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args)> HighContrastChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HighContrastChanged += x, x => _data.HighContrastChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationViewEvents + { + private readonly global::Windows.UI.ViewManagement.ApplicationView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationViewEvents(global::Windows.UI.ViewManagement.ApplicationView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args)> Consolidated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Consolidated += x, x => _data.Consolidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.ApplicationView sender, object args)> VisibleBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.ApplicationView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisibleBoundsChanged += x, x => _data.VisibleBoundsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputPaneEvents + { + private readonly global::Windows.UI.ViewManagement.InputPane _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputPaneEvents(global::Windows.UI.ViewManagement.InputPane data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)> Hiding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Hiding += x, x => _data.Hiding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)> Showing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Showing += x, x => _data.Showing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents + { + private readonly global::Windows.UI.ViewManagement.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::Windows.UI.ViewManagement.StatusBar data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.StatusBar sender, object args)> Hiding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.StatusBar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Hiding += x, x => _data.Hiding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.StatusBar sender, object args)> Showing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.StatusBar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Showing += x, x => _data.Showing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUISettingsEvents + { + private readonly global::Windows.UI.ViewManagement.UISettings _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUISettingsEvents(global::Windows.UI.ViewManagement.UISettings data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, object args)> AdvancedEffectsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AdvancedEffectsEnabledChanged += x, x => _data.AdvancedEffectsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAnimationsEnabledChangedEventArgs args)> AnimationsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAnimationsEnabledChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAnimationsEnabledChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AnimationsEnabledChanged += x, x => _data.AnimationsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAutoHideScrollBarsChangedEventArgs args)> AutoHideScrollBarsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAutoHideScrollBarsChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAutoHideScrollBarsChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutoHideScrollBarsChanged += x, x => _data.AutoHideScrollBarsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, object args)> ColorValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ColorValuesChanged += x, x => _data.ColorValuesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsMessageDurationChangedEventArgs args)> MessageDurationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsMessageDurationChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsMessageDurationChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageDurationChanged += x, x => _data.MessageDurationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, object args)> TextScaleFactorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextScaleFactorChanged += x, x => _data.TextScaleFactorChanged -= x); + } +} + +namespace Windows.UI.ViewManagement.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreInputViewEvents Events(this global::Windows.UI.ViewManagement.Core.CoreInputView item) => new RxCoreInputViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreInputViewEvents + { + private readonly global::Windows.UI.ViewManagement.Core.CoreInputView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreInputViewEvents(global::Windows.UI.ViewManagement.Core.CoreInputView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args)> OcclusionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OcclusionsChanged += x, x => _data.OcclusionsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewHidingEventArgs args)> PrimaryViewHiding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewHidingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewHidingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrimaryViewHiding += x, x => _data.PrimaryViewHiding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewShowingEventArgs args)> PrimaryViewShowing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewShowingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewShowingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrimaryViewShowing += x, x => _data.PrimaryViewShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args)> XYFocusTransferredToPrimaryView => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.XYFocusTransferredToPrimaryView += x, x => _data.XYFocusTransferredToPrimaryView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args)> XYFocusTransferringFromPrimaryView => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.XYFocusTransferringFromPrimaryView += x, x => _data.XYFocusTransferringFromPrimaryView -= x); + } +} + +namespace Windows.UI.WebUI +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebUIBackgroundTaskInstanceRuntimeClassEvents Events(this global::Windows.UI.WebUI.WebUIBackgroundTaskInstanceRuntimeClass item) => new RxWebUIBackgroundTaskInstanceRuntimeClassEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebUIViewEvents Events(this global::Windows.UI.WebUI.WebUIView item) => new RxWebUIViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebUIBackgroundTaskInstanceRuntimeClassEvents + { + private readonly global::Windows.UI.WebUI.WebUIBackgroundTaskInstanceRuntimeClass _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebUIBackgroundTaskInstanceRuntimeClassEvents(global::Windows.UI.WebUI.WebUIBackgroundTaskInstanceRuntimeClass data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason)> Canceled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); + return Handler; + }, x => _data.Canceled += x, x => _data.Canceled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebUIViewEvents + { + private readonly global::Windows.UI.WebUI.WebUIView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebUIViewEvents(global::Windows.UI.WebUI.WebUIView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WebUI.WebUIView sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WebUI.WebUIView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.WebUI.WebUIView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)> ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + } +} + +namespace Windows.UI.WebUI.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebUICommandBarEvents Events(this global::Windows.UI.WebUI.Core.WebUICommandBar item) => new RxWebUICommandBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebUICommandBarConfirmationButtonEvents Events(this global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton item) => new RxWebUICommandBarConfirmationButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebUICommandBarIconButtonEvents Events(this global::Windows.UI.WebUI.Core.WebUICommandBarIconButton item) => new RxWebUICommandBarIconButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebUICommandBarEvents + { + private readonly global::Windows.UI.WebUI.Core.WebUICommandBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebUICommandBarEvents(global::Windows.UI.WebUI.Core.WebUICommandBar data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler() => eventHandler(global::System.Reactive.Unit.Default); + return Handler; + }, x => _data.MenuClosed += x, x => _data.MenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler() => eventHandler(global::System.Reactive.Unit.Default); + return Handler; + }, x => _data.MenuOpened += x, x => _data.MenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.UI.WebUI.Core.WebUICommandBarSizeChangedEventArgs eventArgs) => eventHandler(eventArgs); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebUICommandBarConfirmationButtonEvents + { + private readonly global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebUICommandBarConfirmationButtonEvents(global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args)> ItemInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebUICommandBarIconButtonEvents + { + private readonly global::Windows.UI.WebUI.Core.WebUICommandBarIconButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebUICommandBarIconButtonEvents(global::Windows.UI.WebUI.Core.WebUICommandBarIconButton data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WebUI.Core.WebUICommandBarIconButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args)> ItemInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WebUI.Core.WebUICommandBarIconButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WebUI.Core.WebUICommandBarIconButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + } +} + +namespace Windows.UI.WindowManagement +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppWindowEvents Events(this global::Windows.UI.WindowManagement.AppWindow item) => new RxAppWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDisplayRegionEvents Events(this global::Windows.UI.WindowManagement.DisplayRegion item) => new RxDisplayRegionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowingEnvironmentEvents Events(this global::Windows.UI.WindowManagement.WindowingEnvironment item) => new RxWindowingEnvironmentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppWindowEvents + { + private readonly global::Windows.UI.WindowManagement.AppWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppWindowEvents(global::Windows.UI.WindowManagement.AppWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowChangedEventArgs args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowCloseRequestedEventArgs args)> CloseRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowCloseRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowCloseRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDisplayRegionEvents + { + private readonly global::Windows.UI.WindowManagement.DisplayRegion _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDisplayRegionEvents(global::Windows.UI.WindowManagement.DisplayRegion data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WindowManagement.DisplayRegion sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WindowManagement.DisplayRegion sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.WindowManagement.DisplayRegion sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowingEnvironmentEvents + { + private readonly global::Windows.UI.WindowManagement.WindowingEnvironment _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowingEnvironmentEvents(global::Windows.UI.WindowManagement.WindowingEnvironment data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WindowManagement.WindowingEnvironment sender, global::Windows.UI.WindowManagement.WindowingEnvironmentChangedEventArgs args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WindowManagement.WindowingEnvironment sender, global::Windows.UI.WindowManagement.WindowingEnvironmentChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WindowManagement.WindowingEnvironment sender, global::Windows.UI.WindowManagement.WindowingEnvironmentChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace Windows.UI.Xaml +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::Windows.UI.Xaml.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDebugSettingsEvents Events(this global::Windows.UI.Xaml.DebugSettings item) => new RxDebugSettingsEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDependencyObjectCollectionEvents Events(this global::Windows.UI.Xaml.DependencyObjectCollection item) => new RxDependencyObjectCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::Windows.UI.Xaml.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::Windows.UI.Xaml.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::Windows.UI.Xaml.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::Windows.UI.Xaml.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::Windows.UI.Xaml.Window item) => new RxWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlRootEvents Events(this global::Windows.UI.Xaml.XamlRoot item) => new RxXamlRootEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::Windows.UI.Xaml.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::Windows.UI.Xaml.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnteredBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnteredBackground += x, x => _data.EnteredBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeavingBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeavingBackground += x, x => _data.LeavingBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resuming => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Resuming += x, x => _data.Resuming -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Suspending => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Suspending += x, x => _data.Suspending -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.UnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDebugSettingsEvents + { + private readonly global::Windows.UI.Xaml.DebugSettings _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDebugSettingsEvents(global::Windows.UI.Xaml.DebugSettings data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.BindingFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingFailed += x, x => _data.BindingFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDependencyObjectCollectionEvents + { + private readonly global::Windows.UI.Xaml.DependencyObjectCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDependencyObjectCollectionEvents(global::Windows.UI.Xaml.DependencyObjectCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event)> VectorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::Windows.UI.Xaml.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::Windows.UI.Xaml.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::Windows.UI.Xaml.RxUIElementEvents + { + private readonly global::Windows.UI.Xaml.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::Windows.UI.Xaml.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.FrameworkElement sender, object args)> ActualThemeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.FrameworkElement sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.FrameworkElement sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActualThemeChanged += x, x => _data.ActualThemeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args)> EffectiveViewportChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EffectiveViewportChanged += x, x => _data.EffectiveViewportChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.FrameworkElement sender, object args)> Loading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.FrameworkElement sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.FrameworkElement sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Loading += x, x => _data.Loading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::Windows.UI.Xaml.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::Windows.UI.Xaml.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)> AccessKeyDisplayDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)> AccessKeyDisplayRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)> AccessKeyInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args)> BringIntoViewRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BringIntoViewRequested += x, x => _data.BringIntoViewRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args)> CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args)> ContextCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContextCanceled += x, x => _data.ContextCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args)> ContextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContextRequested += x, x => _data.ContextRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleTapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args)> DragStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DragStarting += x, x => _data.DragStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args)> DropCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DropCompleted += x, x => _data.DropCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args)> GettingFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GettingFocus += x, x => _data.GettingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Holding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.HoldingRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Holding += x, x => _data.Holding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args)> LosingFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args)> NoFocusCandidateFound => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NoFocusCandidateFound += x, x => _data.NoFocusCandidateFound -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCanceled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerCanceled += x, x => _data.PointerCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args)> ProcessKeyboardAccelerators => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProcessKeyboardAccelerators += x, x => _data.ProcessKeyboardAccelerators -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightTapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.RightTappedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.TappedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tapped += x, x => _data.Tapped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::Windows.UI.Xaml.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::Windows.UI.Xaml.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents + { + private readonly global::Windows.UI.Xaml.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::Windows.UI.Xaml.Window data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.WindowActivatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.WindowSizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.VisibilityChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlRootEvents + { + private readonly global::Windows.UI.Xaml.XamlRoot _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlRootEvents(global::Windows.UI.Xaml.XamlRoot data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.XamlRoot sender, global::Windows.UI.Xaml.XamlRootChangedEventArgs args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.XamlRoot sender, global::Windows.UI.Xaml.XamlRootChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.XamlRoot sender, global::Windows.UI.Xaml.XamlRootChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace Windows.UI.Xaml.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBarEvents Events(this global::Windows.UI.Xaml.Controls.AppBar item) => new RxAppBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoSuggestBoxEvents Events(this global::Windows.UI.Xaml.Controls.AutoSuggestBox item) => new RxAutoSuggestBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDatePickerEvents Events(this global::Windows.UI.Xaml.Controls.CalendarDatePicker item) => new RxCalendarDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarViewEvents Events(this global::Windows.UI.Xaml.Controls.CalendarView item) => new RxCalendarViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxColorPickerEvents Events(this global::Windows.UI.Xaml.Controls.ColorPicker item) => new RxColorPickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::Windows.UI.Xaml.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBarEvents Events(this global::Windows.UI.Xaml.Controls.CommandBar item) => new RxCommandBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentDialogEvents Events(this global::Windows.UI.Xaml.Controls.ContentDialog item) => new RxContentDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::Windows.UI.Xaml.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::Windows.UI.Xaml.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.DatePickerFlyout item) => new RxDatePickerFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::Windows.UI.Xaml.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHandwritingViewEvents Events(this global::Windows.UI.Xaml.Controls.HandwritingView item) => new RxHandwritingViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHubEvents Events(this global::Windows.UI.Xaml.Controls.Hub item) => new RxHubEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::Windows.UI.Xaml.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkToolbarEvents Events(this global::Windows.UI.Xaml.Controls.InkToolbar item) => new RxInkToolbarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkToolbarFlyoutItemEvents Events(this global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem item) => new RxInkToolbarFlyoutItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemCollectionEvents Events(this global::Windows.UI.Xaml.Controls.ItemCollection item) => new RxItemCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::Windows.UI.Xaml.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemsPresenterEvents Events(this global::Windows.UI.Xaml.Controls.ItemsPresenter item) => new RxItemsPresenterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListPickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.ListPickerFlyout item) => new RxListPickerFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewBaseEvents Events(this global::Windows.UI.Xaml.Controls.ListViewBase item) => new RxListViewBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::Windows.UI.Xaml.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaTransportControlsEvents Events(this global::Windows.UI.Xaml.Controls.MediaTransportControls item) => new RxMediaTransportControlsEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuFlyoutItemEvents Events(this global::Windows.UI.Xaml.Controls.MenuFlyoutItem item) => new RxMenuFlyoutItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationViewEvents Events(this global::Windows.UI.Xaml.Controls.NavigationView item) => new RxNavigationViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::Windows.UI.Xaml.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.PickerFlyout item) => new RxPickerFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPivotEvents Events(this global::Windows.UI.Xaml.Controls.Pivot item) => new RxPivotEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRatingControlEvents Events(this global::Windows.UI.Xaml.Controls.RatingControl item) => new RxRatingControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRefreshContainerEvents Events(this global::Windows.UI.Xaml.Controls.RefreshContainer item) => new RxRefreshContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRefreshVisualizerEvents Events(this global::Windows.UI.Xaml.Controls.RefreshVisualizer item) => new RxRefreshVisualizerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichEditBoxEvents Events(this global::Windows.UI.Xaml.Controls.RichEditBox item) => new RxRichEditBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBlockEvents Events(this global::Windows.UI.Xaml.Controls.RichTextBlock item) => new RxRichTextBlockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBlockOverflowEvents Events(this global::Windows.UI.Xaml.Controls.RichTextBlockOverflow item) => new RxRichTextBlockOverflowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::Windows.UI.Xaml.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSearchBoxEvents Events(this global::Windows.UI.Xaml.Controls.SearchBox item) => new RxSearchBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSemanticZoomEvents Events(this global::Windows.UI.Xaml.Controls.SemanticZoom item) => new RxSemanticZoomEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSettingsFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.SettingsFlyout item) => new RxSettingsFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitButtonEvents Events(this global::Windows.UI.Xaml.Controls.SplitButton item) => new RxSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitViewEvents Events(this global::Windows.UI.Xaml.Controls.SplitView item) => new RxSplitViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStackPanelEvents Events(this global::Windows.UI.Xaml.Controls.StackPanel item) => new RxStackPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSwapChainPanelEvents Events(this global::Windows.UI.Xaml.Controls.SwapChainPanel item) => new RxSwapChainPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSwipeItemEvents Events(this global::Windows.UI.Xaml.Controls.SwipeItem item) => new RxSwipeItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBlockEvents Events(this global::Windows.UI.Xaml.Controls.TextBlock item) => new RxTextBlockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::Windows.UI.Xaml.Controls.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimePickerEvents Events(this global::Windows.UI.Xaml.Controls.TimePicker item) => new RxTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimePickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.TimePickerFlyout item) => new RxTimePickerFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleSplitButtonEvents Events(this global::Windows.UI.Xaml.Controls.ToggleSplitButton item) => new RxToggleSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleSwitchEvents Events(this global::Windows.UI.Xaml.Controls.ToggleSwitch item) => new RxToggleSwitchEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::Windows.UI.Xaml.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::Windows.UI.Xaml.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTwoPaneViewEvents Events(this global::Windows.UI.Xaml.Controls.TwoPaneView item) => new RxTwoPaneViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVirtualizingStackPanelEvents Events(this global::Windows.UI.Xaml.Controls.VirtualizingStackPanel item) => new RxVirtualizingStackPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebViewEvents Events(this global::Windows.UI.Xaml.Controls.WebView item) => new RxWebViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBarEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.AppBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBarEvents(global::Windows.UI.Xaml.Controls.AppBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoSuggestBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.AutoSuggestBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoSuggestBoxEvents(global::Windows.UI.Xaml.Controls.AutoSuggestBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args)> QuerySubmitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args)> SuggestionChosen => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SuggestionChosen += x, x => _data.SuggestionChosen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args)> TextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDatePickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.CalendarDatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDatePickerEvents(global::Windows.UI.Xaml.Controls.CalendarDatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs e)> CalendarViewDayItemChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args)> DateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.CalendarView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarViewEvents(global::Windows.UI.Xaml.Controls.CalendarView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args)> CalendarViewDayItemChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args)> SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxColorPickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.ColorPicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxColorPickerEvents(global::Windows.UI.Xaml.Controls.ColorPicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)> ColorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::Windows.UI.Xaml.Controls.Primitives.RxSelectorEvents + { + private readonly global::Windows.UI.Xaml.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::Windows.UI.Xaml.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args)> TextSubmitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextSubmitted += x, x => _data.TextSubmitted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBarEvents : global::Windows.UI.Xaml.Controls.RxAppBarEvents + { + private readonly global::Windows.UI.Xaml.Controls.CommandBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBarEvents(global::Windows.UI.Xaml.Controls.CommandBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args)> DynamicOverflowItemsChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DynamicOverflowItemsChanging += x, x => _data.DynamicOverflowItemsChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentDialogEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.ContentDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentDialogEvents(global::Windows.UI.Xaml.Controls.ContentDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)> CloseButtonClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CloseButtonClick += x, x => _data.CloseButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)> PrimaryButtonClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrimaryButtonClick += x, x => _data.PrimaryButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)> SecondaryButtonClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SecondaryButtonClick += x, x => _data.SecondaryButtonClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::Windows.UI.Xaml.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args)> FocusDisengaged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FocusDisengaged += x, x => _data.FocusDisengaged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args)> FocusEngaged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FocusEngaged += x, x => _data.FocusEngaged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::Windows.UI.Xaml.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args)> SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.DatePickerFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerFlyoutEvents(global::Windows.UI.Xaml.Controls.DatePickerFlyout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args)> DatePicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DatePicked += x, x => _data.DatePicked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::Windows.UI.Xaml.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHandwritingViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.HandwritingView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHandwritingViewEvents(global::Windows.UI.Xaml.Controls.HandwritingView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHubEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Hub _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHubEvents(global::Windows.UI.Xaml.Controls.Hub data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SectionHeaderClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.HubSectionHeaderClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SectionHeaderClick += x, x => _data.SectionHeaderClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SectionsInViewChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SectionsInViewChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SectionsInViewChanged += x, x => _data.SectionsInViewChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::Windows.UI.Xaml.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkToolbarEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.InkToolbar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkToolbarEvents(global::Windows.UI.Xaml.Controls.InkToolbar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> ActiveToolChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActiveToolChanged += x, x => _data.ActiveToolChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> EraseAllClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EraseAllClicked += x, x => _data.EraseAllClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> InkDrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InkDrawingAttributesChanged += x, x => _data.InkDrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> IsRulerButtonCheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsRulerButtonCheckedChanged += x, x => _data.IsRulerButtonCheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args)> IsStencilButtonCheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsStencilButtonCheckedChanged += x, x => _data.IsStencilButtonCheckedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkToolbarFlyoutItemEvents : global::Windows.UI.Xaml.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkToolbarFlyoutItemEvents(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)> Checked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)> Unchecked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemCollectionEvents + { + private readonly global::Windows.UI.Xaml.Controls.ItemCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemCollectionEvents(global::Windows.UI.Xaml.Controls.ItemCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event)> VectorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::Windows.UI.Xaml.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::Windows.UI.Xaml.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemsPresenterEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.ItemsPresenter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemsPresenterEvents(global::Windows.UI.Xaml.Controls.ItemsPresenter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListPickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.ListPickerFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListPickerFlyoutEvents(global::Windows.UI.Xaml.Controls.ListPickerFlyout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args)> ItemsPicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemsPicked += x, x => _data.ItemsPicked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewBaseEvents : global::Windows.UI.Xaml.Controls.Primitives.RxSelectorEvents + { + private readonly global::Windows.UI.Xaml.Controls.ListViewBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewBaseEvents(global::Windows.UI.Xaml.Controls.ListViewBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args)> ChoosingGroupHeaderContainer => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ChoosingGroupHeaderContainer += x, x => _data.ChoosingGroupHeaderContainer -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args)> ChoosingItemContainer => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ChoosingItemContainer += x, x => _data.ChoosingItemContainer -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args)> ContainerContentChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContainerContentChanging += x, x => _data.ContainerContentChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args)> DragItemsCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragItemsStarting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.DragItemsStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ItemClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::Windows.UI.Xaml.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarkerReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Media.TimelineMarkerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarkerReached += x, x => _data.MarkerReached -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args)> PartialMediaFailureDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PartialMediaFailureDetected += x, x => _data.PartialMediaFailureDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Media.RateChangedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RateChanged += x, x => _data.RateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SeekCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VolumeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaTransportControlsEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.MediaTransportControls _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaTransportControlsEvents(global::Windows.UI.Xaml.Controls.MediaTransportControls data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args)> ThumbnailRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ThumbnailRequested += x, x => _data.ThumbnailRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuFlyoutItemEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.MenuFlyoutItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuFlyoutItemEvents(global::Windows.UI.Xaml.Controls.MenuFlyoutItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.NavigationView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationViewEvents(global::Windows.UI.Xaml.Controls.NavigationView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args)> BackRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args)> DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args)> ItemInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, object args)> PaneClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args)> PaneClosing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, object args)> PaneOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, object args)> PaneOpening => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args)> SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::Windows.UI.Xaml.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args)> PasswordChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PasswordChanging += x, x => _data.PasswordChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paste => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paste += x, x => _data.Paste -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.PickerFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPickerFlyoutEvents(global::Windows.UI.Xaml.Controls.PickerFlyout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args)> Confirmed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Confirmed += x, x => _data.Confirmed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPivotEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Pivot _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPivotEvents(global::Windows.UI.Xaml.Controls.Pivot data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PivotItemLoaded += x, x => _data.PivotItemLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PivotItemLoading += x, x => _data.PivotItemLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemUnloaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PivotItemUnloaded += x, x => _data.PivotItemUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemUnloading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PivotItemUnloading += x, x => _data.PivotItemUnloading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRatingControlEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.RatingControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRatingControlEvents(global::Windows.UI.Xaml.Controls.RatingControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RatingControl sender, object args)> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RatingControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RatingControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRefreshContainerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.RefreshContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRefreshContainerEvents(global::Windows.UI.Xaml.Controls.RefreshContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)> RefreshRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRefreshVisualizerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.RefreshVisualizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRefreshVisualizerEvents(global::Windows.UI.Xaml.Controls.RefreshVisualizer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)> RefreshRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args)> RefreshStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RefreshStateChanged += x, x => _data.RefreshStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichEditBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.RichEditBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichEditBoxEvents(global::Windows.UI.Xaml.Controls.RichEditBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)> CandidateWindowBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args)> ContentLinkChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLinkChanged += x, x => _data.ContentLinkChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)> ContentLinkInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLinkInvoked += x, x => _data.ContentLinkInvoked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)> CopyingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)> CuttingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paste => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paste += x, x => _data.Paste -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args)> SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args)> TextChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)> TextCompositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)> TextCompositionEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)> TextCompositionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBlockEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.RichTextBlock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBlockEvents(global::Windows.UI.Xaml.Controls.RichTextBlock data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)> IsTextTrimmedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBlockOverflowEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.RichTextBlockOverflow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBlockOverflowEvents(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)> IsTextTrimmedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::Windows.UI.Xaml.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args)> AnchorRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AnchorRequested += x, x => _data.AnchorRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DirectManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.DirectManipulationCompleted += x, x => _data.DirectManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DirectManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.DirectManipulationStarted += x, x => _data.DirectManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ViewChanged += x, x => _data.ViewChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ViewChanging => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ViewChanging += x, x => _data.ViewChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSearchBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.SearchBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSearchBoxEvents(global::Windows.UI.Xaml.Controls.SearchBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args)> PrepareForFocusOnKeyboardInput => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrepareForFocusOnKeyboardInput += x, x => _data.PrepareForFocusOnKeyboardInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args)> QueryChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QueryChanged += x, x => _data.QueryChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args)> QuerySubmitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args)> ResultSuggestionChosen => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args)> SuggestionsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSemanticZoomEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.SemanticZoom _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSemanticZoomEvents(global::Windows.UI.Xaml.Controls.SemanticZoom data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ViewChangeCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ViewChangeCompleted += x, x => _data.ViewChangeCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ViewChangeStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ViewChangeStarted += x, x => _data.ViewChangeStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSettingsFlyoutEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.SettingsFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSettingsFlyoutEvents(global::Windows.UI.Xaml.Controls.SettingsFlyout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.BackClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackClick += x, x => _data.BackClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitButtonEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.SplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitButtonEvents(global::Windows.UI.Xaml.Controls.SplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args)> Click => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.SplitView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitViewEvents(global::Windows.UI.Xaml.Controls.SplitView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, object args)> PaneClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args)> PaneClosing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, object args)> PaneOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, object args)> PaneOpening => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStackPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.StackPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStackPanelEvents(global::Windows.UI.Xaml.Controls.StackPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSwapChainPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.SwapChainPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSwapChainPanelEvents(global::Windows.UI.Xaml.Controls.SwapChainPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args)> CompositionScaleChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CompositionScaleChanged += x, x => _data.CompositionScaleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSwipeItemEvents + { + private readonly global::Windows.UI.Xaml.Controls.SwipeItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSwipeItemEvents(global::Windows.UI.Xaml.Controls.SwipeItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Invoked += x, x => _data.Invoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBlockEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.TextBlock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBlockEvents(global::Windows.UI.Xaml.Controls.TextBlock data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)> IsTextTrimmedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::Windows.UI.Xaml.Controls.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args)> BeforeTextChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BeforeTextChanging += x, x => _data.BeforeTextChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)> CandidateWindowBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)> CopyingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)> CuttingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paste => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paste += x, x => _data.Paste -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args)> SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args)> TextChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)> TextCompositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)> TextCompositionEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)> TextCompositionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimePickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.TimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimePickerEvents(global::Windows.UI.Xaml.Controls.TimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args)> SelectedTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedTimeChanged += x, x => _data.SelectedTimeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TimeChanged += x, x => _data.TimeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimePickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.TimePickerFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimePickerFlyoutEvents(global::Windows.UI.Xaml.Controls.TimePickerFlyout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args)> TimePicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TimePicked += x, x => _data.TimePicked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleSplitButtonEvents : global::Windows.UI.Xaml.Controls.RxSplitButtonEvents + { + private readonly global::Windows.UI.Xaml.Controls.ToggleSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleSplitButtonEvents(global::Windows.UI.Xaml.Controls.ToggleSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args)> IsCheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsCheckedChanged += x, x => _data.IsCheckedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleSwitchEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.ToggleSwitch _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleSwitchEvents(global::Windows.UI.Xaml.Controls.ToggleSwitch data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Toggled += x, x => _data.Toggled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::Windows.UI.Xaml.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::Windows.UI.Xaml.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args)> Collapsed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args)> DragItemsCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args)> DragItemsStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args)> Expanding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Expanding += x, x => _data.Expanding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args)> ItemInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTwoPaneViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.TwoPaneView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTwoPaneViewEvents(global::Windows.UI.Xaml.Controls.TwoPaneView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TwoPaneView sender, object args)> ModeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TwoPaneView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TwoPaneView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ModeChanged += x, x => _data.ModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVirtualizingStackPanelEvents : global::Windows.UI.Xaml.Controls.Primitives.RxOrientedVirtualizingPanelEvents + { + private readonly global::Windows.UI.Xaml.Controls.VirtualizingStackPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVirtualizingStackPanelEvents(global::Windows.UI.Xaml.Controls.VirtualizingStackPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CleanUpVirtualizedItemEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CleanUpVirtualizedItemEvent += x, x => _data.CleanUpVirtualizedItemEvent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebViewEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.WebView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebViewEvents(global::Windows.UI.Xaml.Controls.WebView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.WebViewNavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.NotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args)> SeparateProcessLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SeparateProcessLost += x, x => _data.SeparateProcessLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + } +} + +namespace Windows.UI.Xaml.Controls.Maps +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCustomMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource item) => new RxCustomMapTileDataSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHttpMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource item) => new RxHttpMapTileDataSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLocalMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource item) => new RxLocalMapTileDataSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMapControlEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapControl item) => new RxMapControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMapControlDataHelperEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapControlDataHelper item) => new RxMapControlDataHelperEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMapElementsLayerEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer item) => new RxMapElementsLayerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMapSceneEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapScene item) => new RxMapSceneEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCustomMapTileDataSourceEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCustomMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args)> BitmapRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHttpMapTileDataSourceEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHttpMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)> UriRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLocalMapTileDataSourceEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLocalMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)> UriRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMapControlEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.MapControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMapControlEvents(global::Windows.UI.Xaml.Controls.Maps.MapControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args)> ActualCameraChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActualCameraChanged += x, x => _data.ActualCameraChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args)> ActualCameraChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActualCameraChanging += x, x => _data.ActualCameraChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> CenterChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CenterChanged += x, x => _data.CenterChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args)> CustomExperienceChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CustomExperienceChanged += x, x => _data.CustomExperienceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> HeadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadingChanged += x, x => _data.HeadingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> LoadingStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LoadingStatusChanged += x, x => _data.LoadingStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args)> MapContextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)> MapDoubleTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapDoubleTapped += x, x => _data.MapDoubleTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args)> MapElementClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args)> MapElementPointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args)> MapElementPointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)> MapHolding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapHolding += x, x => _data.MapHolding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args)> MapRightTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapRightTapped += x, x => _data.MapRightTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)> MapTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapTapped += x, x => _data.MapTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> PitchChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PitchChanged += x, x => _data.PitchChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)> TargetCameraChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> TransformOriginChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransformOriginChanged += x, x => _data.TransformOriginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> ZoomLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ZoomLevelChanged += x, x => _data.ZoomLevelChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMapControlDataHelperEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.MapControlDataHelper _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMapControlDataHelperEvents(global::Windows.UI.Xaml.Controls.Maps.MapControlDataHelper data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkClickEventArgs args)> BusinessLandmarkClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BusinessLandmarkClick += x, x => _data.BusinessLandmarkClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerEnteredEventArgs args)> BusinessLandmarkPointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerEnteredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerEnteredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BusinessLandmarkPointerEntered += x, x => _data.BusinessLandmarkPointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerExitedEventArgs args)> BusinessLandmarkPointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerExitedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerExitedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BusinessLandmarkPointerExited += x, x => _data.BusinessLandmarkPointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkRightTappedEventArgs args)> BusinessLandmarkRightTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkRightTappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkRightTappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BusinessLandmarkRightTapped += x, x => _data.BusinessLandmarkRightTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureClickEventArgs args)> TransitFeatureClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransitFeatureClick += x, x => _data.TransitFeatureClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerEnteredEventArgs args)> TransitFeaturePointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerEnteredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerEnteredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransitFeaturePointerEntered += x, x => _data.TransitFeaturePointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerExitedEventArgs args)> TransitFeaturePointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerExitedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerExitedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransitFeaturePointerExited += x, x => _data.TransitFeaturePointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureRightTappedEventArgs args)> TransitFeatureRightTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureRightTappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureRightTappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransitFeatureRightTapped += x, x => _data.TransitFeatureRightTapped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMapElementsLayerEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMapElementsLayerEvents(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args)> MapContextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args)> MapElementClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args)> MapElementPointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args)> MapElementPointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMapSceneEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.MapScene _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMapSceneEvents(global::Windows.UI.Xaml.Controls.Maps.MapScene data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)> TargetCameraChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + } +} + +namespace Windows.UI.Xaml.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCarouselPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.CarouselPanel item) => new RxCarouselPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxColorSpectrumEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum item) => new RxColorSpectrumEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFlyoutBaseEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase item) => new RxFlyoutBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIScrollSnapPointsInfoEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo item) => new RxIScrollSnapPointsInfoEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLoopingSelectorEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.LoopingSelector item) => new RxLoopingSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLoopingSelectorPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.LoopingSelectorPanel item) => new RxLoopingSelectorPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxOrientedVirtualizingPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel item) => new RxOrientedVirtualizingPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPivotPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.PivotPanel item) => new RxPivotPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::Windows.UI.Xaml.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCarouselPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.CarouselPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCarouselPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.CarouselPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxColorSpectrumEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxColorSpectrumEvents(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)> ColorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFlyoutBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFlyoutBaseEvents(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIScrollSnapPointsInfoEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIScrollSnapPointsInfoEvents(global::Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLoopingSelectorEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.LoopingSelector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLoopingSelectorEvents(global::Windows.UI.Xaml.Controls.Primitives.LoopingSelector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLoopingSelectorPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.LoopingSelectorPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLoopingSelectorPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.LoopingSelectorPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxOrientedVirtualizingPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxOrientedVirtualizingPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPivotPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.PivotPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPivotPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.PivotPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::Windows.UI.Xaml.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::Windows.UI.Xaml.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::Windows.UI.Xaml.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::Windows.UI.Xaml.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::Windows.UI.Xaml.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::Windows.UI.Xaml.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::Windows.UI.Xaml.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::Windows.UI.Xaml.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace Windows.UI.Xaml.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::Windows.UI.Xaml.Data.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::Windows.UI.Xaml.Data.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::Windows.UI.Xaml.Data.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Data.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace Windows.UI.Xaml.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentLinkEvents Events(this global::Windows.UI.Xaml.Documents.ContentLink item) => new RxContentLinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::Windows.UI.Xaml.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextElementEvents Events(this global::Windows.UI.Xaml.Documents.TextElement item) => new RxTextElementEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentLinkEvents : global::Windows.UI.Xaml.Documents.RxTextElementEvents + { + private readonly global::Windows.UI.Xaml.Documents.ContentLink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentLinkEvents(global::Windows.UI.Xaml.Documents.ContentLink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Invoked += x, x => _data.Invoked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::Windows.UI.Xaml.Documents.RxTextElementEvents + { + private readonly global::Windows.UI.Xaml.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::Windows.UI.Xaml.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args)> Click => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextElementEvents + { + private readonly global::Windows.UI.Xaml.Documents.TextElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextElementEvents(global::Windows.UI.Xaml.Documents.TextElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)> AccessKeyDisplayDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)> AccessKeyDisplayRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)> AccessKeyInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + } +} + +namespace Windows.UI.Xaml.Hosting +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDesignerAppManagerEvents Events(this global::Windows.UI.Xaml.Hosting.DesignerAppManager item) => new RxDesignerAppManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDesktopWindowXamlSourceEvents Events(this global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource item) => new RxDesktopWindowXamlSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDesignerAppManagerEvents + { + private readonly global::Windows.UI.Xaml.Hosting.DesignerAppManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDesignerAppManagerEvents(global::Windows.UI.Xaml.Hosting.DesignerAppManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Hosting.DesignerAppManager sender, global::Windows.UI.Xaml.Hosting.DesignerAppExitedEventArgs args)> DesignerAppExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Hosting.DesignerAppManager sender, global::Windows.UI.Xaml.Hosting.DesignerAppExitedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Hosting.DesignerAppManager sender, global::Windows.UI.Xaml.Hosting.DesignerAppExitedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DesignerAppExited += x, x => _data.DesignerAppExited -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDesktopWindowXamlSourceEvents + { + private readonly global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDesktopWindowXamlSourceEvents(global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceGotFocusEventArgs args)> GotFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceGotFocusEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceGotFocusEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceTakeFocusRequestedEventArgs args)> TakeFocusRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceTakeFocusRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceTakeFocusRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TakeFocusRequested += x, x => _data.TakeFocusRequested -= x); + } +} + +namespace Windows.UI.Xaml.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxKeyboardAcceleratorEvents Events(this global::Windows.UI.Xaml.Input.KeyboardAccelerator item) => new RxKeyboardAcceleratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlUICommandEvents Events(this global::Windows.UI.Xaml.Input.XamlUICommand item) => new RxXamlUICommandEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxKeyboardAcceleratorEvents + { + private readonly global::Windows.UI.Xaml.Input.KeyboardAccelerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxKeyboardAcceleratorEvents(global::Windows.UI.Xaml.Input.KeyboardAccelerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Invoked += x, x => _data.Invoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlUICommandEvents + { + private readonly global::Windows.UI.Xaml.Input.XamlUICommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlUICommandEvents(global::Windows.UI.Xaml.Input.XamlUICommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args)> CanExecuteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CanExecuteRequested += x, x => _data.CanExecuteRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args)> ExecuteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ExecuteRequested += x, x => _data.ExecuteRequested -= x); + } +} + +namespace Windows.UI.Xaml.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIBindableObservableVectorEvents Events(this global::Windows.UI.Xaml.Interop.IBindableObservableVector item) => new RxIBindableObservableVectorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIBindableObservableVectorEvents + { + private readonly global::Windows.UI.Xaml.Interop.IBindableObservableVector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIBindableObservableVectorEvents(global::Windows.UI.Xaml.Interop.IBindableObservableVector data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Interop.IBindableObservableVector vector, object e)> VectorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Interop.IBindableObservableVector vector, object e) => eventHandler((vector, e)); + return Handler; + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + } +} + +namespace Windows.UI.Xaml.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageBrushEvents Events(this global::Windows.UI.Xaml.Media.ImageBrush item) => new RxImageBrushEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLoadedImageSurfaceEvents Events(this global::Windows.UI.Xaml.Media.LoadedImageSurface item) => new RxLoadedImageSurfaceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageBrushEvents + { + private readonly global::Windows.UI.Xaml.Media.ImageBrush _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageBrushEvents(global::Windows.UI.Xaml.Media.ImageBrush data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLoadedImageSurfaceEvents + { + private readonly global::Windows.UI.Xaml.Media.LoadedImageSurface _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLoadedImageSurfaceEvents(global::Windows.UI.Xaml.Media.LoadedImageSurface data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args)> LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace Windows.UI.Xaml.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxConnectedAnimationEvents Events(this global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation item) => new RxConnectedAnimationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::Windows.UI.Xaml.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxConnectedAnimationEvents + { + private readonly global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxConnectedAnimationEvents(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents + { + private readonly global::Windows.UI.Xaml.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::Windows.UI.Xaml.Media.Animation.Timeline data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } +} + +namespace Windows.UI.Xaml.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapImageEvents Events(this global::Windows.UI.Xaml.Media.Imaging.BitmapImage item) => new RxBitmapImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSvgImageSourceEvents Events(this global::Windows.UI.Xaml.Media.Imaging.SvgImageSource item) => new RxSvgImageSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapImageEvents + { + private readonly global::Windows.UI.Xaml.Media.Imaging.BitmapImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapImageEvents(global::Windows.UI.Xaml.Media.Imaging.BitmapImage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSvgImageSourceEvents + { + private readonly global::Windows.UI.Xaml.Media.Imaging.SvgImageSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSvgImageSourceEvents(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args)> OpenFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + } +} + +namespace Windows.UI.Xaml.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintDocumentEvents Events(this global::Windows.UI.Xaml.Printing.PrintDocument item) => new RxPrintDocumentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintDocumentEvents + { + private readonly global::Windows.UI.Xaml.Printing.PrintDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintDocumentEvents(global::Windows.UI.Xaml.Printing.PrintDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddPages => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Printing.AddPagesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddPages += x, x => _data.AddPages -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPreviewPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Printing.GetPreviewPageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPreviewPage += x, x => _data.GetPreviewPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paginate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Printing.PaginateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paginate += x, x => _data.Paginate -= x); + } +} + +namespace Windows.Web.Http.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHttpDiagnosticProviderEvents Events(this global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider item) => new RxHttpDiagnosticProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHttpDiagnosticProviderEvents + { + private readonly global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHttpDiagnosticProviderEvents(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestResponseCompletedEventArgs args)> RequestResponseCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestResponseCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestResponseCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RequestResponseCompleted += x, x => _data.RequestResponseCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestSentEventArgs args)> RequestSent => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestSentEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestSentEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RequestSent += x, x => _data.RequestSent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderResponseReceivedEventArgs args)> ResponseReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderResponseReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderResponseReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResponseReceived += x, x => _data.ResponseReceived -= x); + } +} + +namespace Windows.Web.Http.Filters +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHttpBaseProtocolFilterEvents Events(this global::Windows.Web.Http.Filters.HttpBaseProtocolFilter item) => new RxHttpBaseProtocolFilterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHttpBaseProtocolFilterEvents + { + private readonly global::Windows.Web.Http.Filters.HttpBaseProtocolFilter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHttpBaseProtocolFilterEvents(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args)> ServerCustomValidationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + } +} + +namespace Windows.Web.UI +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIWebViewControlEvents Events(this global::Windows.Web.UI.IWebViewControl item) => new RxIWebViewControlEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIWebViewControlEvents + { + private readonly global::Windows.Web.UI.IWebViewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIWebViewControlEvents(global::Windows.Web.UI.IWebViewControl data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)> ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + } +} + +namespace Windows.Web.UI.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebViewControlEvents Events(this global::Windows.Web.UI.Interop.WebViewControl item) => new RxWebViewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebViewControlProcessEvents Events(this global::Windows.Web.UI.Interop.WebViewControlProcess item) => new RxWebViewControlProcessEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebViewControlEvents + { + private readonly global::Windows.Web.UI.Interop.WebViewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebViewControlEvents(global::Windows.Web.UI.Interop.WebViewControl data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args)> AcceleratorKeyPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AcceleratorKeyPressed += x, x => _data.AcceleratorKeyPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, object args)> GotFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, object args)> LostFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args)> MoveFocusRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MoveFocusRequested += x, x => _data.MoveFocusRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)> ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebViewControlProcessEvents + { + private readonly global::Windows.Web.UI.Interop.WebViewControlProcess _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebViewControlProcessEvents(global::Windows.Web.UI.Interop.WebViewControlProcess data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args)> ProcessExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProcessExited += x, x => _data.ProcessExited -= x); + } +} + +namespace Windows.ApplicationModel.Calls +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PhoneCallManagerCallStateChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Calls.PhoneCallManager.CallStateChanged += x, x => global::Windows.ApplicationModel.Calls.PhoneCallManager.CallStateChanged -= x); + } +} + +namespace Windows.ApplicationModel.Chat +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RcsManagerTransportListChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged += x, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged -= x); + } +} + +namespace Windows.ApplicationModel.Core +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationBackgroundActivated => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated += x, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationEnteredBackground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.EnteredBackgroundEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationExiting => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationLeavingBackground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.LeavingBackgroundEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationResuming => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationSuspending => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.SuspendingEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationUnhandledErrorDetected => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected += x, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected -= x); + } +} + +namespace Windows.ApplicationModel.DataTransfer +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ClipboardContentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ClipboardHistoryChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.DataTransfer.ClipboardHistoryChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.DataTransfer.ClipboardHistoryChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ClipboardHistoryEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ClipboardRoamingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged -= x); + } +} + +namespace Windows.Foundation.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AsyncCausalityTracerTracingStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged += x, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged -= x); + } +} + +namespace Windows.Gaming.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ArcadeStickArcadeStickAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.ArcadeStick>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ArcadeStickArcadeStickRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.ArcadeStick>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FlightStickFlightStickAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.FlightStick>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FlightStickFlightStickRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.FlightStick>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GamepadGamepadAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.Gamepad>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded += x, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GamepadGamepadRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.Gamepad>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved += x, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RacingWheelRacingWheelAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RacingWheel>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RacingWheelRacingWheelRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RacingWheel>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RawGameControllerRawGameControllerAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RawGameController>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RawGameControllerRawGameControllerRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RawGameController>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable UINavigationControllerUINavigationControllerAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.UINavigationController>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable UINavigationControllerUINavigationControllerRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.UINavigationController>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved -= x); + } +} + +namespace Windows.Gaming.Preview.GamesEnumeration +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GameListGameAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Gaming.Preview.GamesEnumeration.GameListEntry game) => eventHandler(game); + return Handler; + }, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameAdded += x, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GameListGameRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(string identifier) => eventHandler(identifier); + return Handler; + }, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameRemoved += x, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GameListGameUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Gaming.Preview.GamesEnumeration.GameListEntry game) => eventHandler(game); + return Handler; + }, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameUpdated += x, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameUpdated -= x); + } +} + +namespace Windows.Gaming.UI +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GameBarIsInputRedirectedChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged += x, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GameBarVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged += x, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged -= x); + } +} + +namespace Windows.Graphics.Display +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> DisplayInformationDisplayContentsInvalidated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable DisplayPropertiesColorProfileChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable DisplayPropertiesDisplayContentsInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable DisplayPropertiesLogicalDpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable DisplayPropertiesOrientationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable DisplayPropertiesStereoEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged -= x); + } +} + +namespace Windows.Graphics.Holographic +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable HolographicSpaceIsAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged += x, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged -= x); + } +} + +namespace Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlChannelDownPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.ChannelDownPressed += x, x => global::Windows.Media.MediaControl.ChannelDownPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlChannelUpPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.ChannelUpPressed += x, x => global::Windows.Media.MediaControl.ChannelUpPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlFastForwardPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.FastForwardPressed += x, x => global::Windows.Media.MediaControl.FastForwardPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlNextTrackPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.NextTrackPressed += x, x => global::Windows.Media.MediaControl.NextTrackPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlPausePressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.PausePressed += x, x => global::Windows.Media.MediaControl.PausePressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlPlayPauseTogglePressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.PlayPauseTogglePressed += x, x => global::Windows.Media.MediaControl.PlayPauseTogglePressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlPlayPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.PlayPressed += x, x => global::Windows.Media.MediaControl.PlayPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlPreviousTrackPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.PreviousTrackPressed += x, x => global::Windows.Media.MediaControl.PreviousTrackPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlRecordPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.RecordPressed += x, x => global::Windows.Media.MediaControl.RecordPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlRewindPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.RewindPressed += x, x => global::Windows.Media.MediaControl.RewindPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlSoundLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.SoundLevelChanged += x, x => global::Windows.Media.MediaControl.SoundLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlStopPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.StopPressed += x, x => global::Windows.Media.MediaControl.StopPressed -= x); + } +} + +namespace Windows.Media.Core.Preview +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SoundLevelBrokerSoundLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged += x, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged -= x); + } +} + +namespace Windows.Media.Devices +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaDeviceDefaultAudioCaptureDeviceChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Devices.DefaultAudioCaptureDeviceChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Media.Devices.DefaultAudioCaptureDeviceChangedEventArgs args) => eventHandler(args); + return Handler; + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaDeviceDefaultAudioRenderDeviceChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Devices.DefaultAudioRenderDeviceChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Media.Devices.DefaultAudioRenderDeviceChangedEventArgs args) => eventHandler(args); + return Handler; + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged -= x); + } +} + +namespace Windows.Media.Playback +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BackgroundMediaPlayerMessageReceivedFromBackground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BackgroundMediaPlayerMessageReceivedFromForeground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground -= x); + } +} + +namespace Windows.Networking.Connectivity +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable NetworkInformationNetworkStatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged += x, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged -= x); + } +} + +namespace Windows.Networking.NetworkOperators +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ESimManagerServiceInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged += x, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged -= x); + } +} + +namespace Windows.Networking.Proximity +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PeerFinderConnectionRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Networking.Proximity.ConnectionRequestedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Networking.Proximity.ConnectionRequestedEventArgs args) => eventHandler(args); + return Handler; + }, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested += x, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PeerFinderTriggeredConnectionStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Networking.Proximity.TriggeredConnectionStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Networking.Proximity.TriggeredConnectionStateChangedEventArgs args) => eventHandler(args); + return Handler; + }, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged += x, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged -= x); + } +} + +namespace Windows.Networking.PushNotifications +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PushNotificationChannelManagerChannelsRevoked => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Networking.PushNotifications.PushNotificationChannelsRevokedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Networking.PushNotifications.PushNotificationChannelsRevokedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Networking.PushNotifications.PushNotificationChannelManager.ChannelsRevoked += x, x => global::Windows.Networking.PushNotifications.PushNotificationChannelManager.ChannelsRevoked -= x); + } +} + +namespace Windows.Perception.Spatial +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SpatialStageFrameOfReferenceCurrentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged += x, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged -= x); + } +} + +namespace Windows.Phone.System.Power +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerPowerSavingModeChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged += x, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged -= x); + } +} + +namespace Windows.Phone.UI.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable HardwareButtonsBackPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.BackPressedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Phone.UI.Input.BackPressedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable HardwareButtonsCameraHalfPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.CameraEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable HardwareButtonsCameraPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.CameraEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable HardwareButtonsCameraReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.CameraEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased -= x); + } +} + +namespace Windows.Security.Authentication.Identity.Provider +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SecondaryAuthenticationFactorAuthenticationAuthenticationStageChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged += x, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged -= x); + } +} + +namespace Windows.Security.EnterpriseData +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ProtectionPolicyManagerPolicyChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.PolicyChanged += x, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.PolicyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ProtectionPolicyManagerProtectedAccessResumed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Security.EnterpriseData.ProtectedAccessResumedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Security.EnterpriseData.ProtectedAccessResumedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedAccessResumed += x, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedAccessResumed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ProtectionPolicyManagerProtectedAccessSuspending => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Security.EnterpriseData.ProtectedAccessSuspendingEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Security.EnterpriseData.ProtectedAccessSuspendingEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedAccessSuspending += x, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedAccessSuspending -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ProtectionPolicyManagerProtectedContentRevoked => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Security.EnterpriseData.ProtectedContentRevokedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Security.EnterpriseData.ProtectedContentRevokedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedContentRevoked += x, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedContentRevoked -= x); + } +} + +namespace Windows.System +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MemoryManagerAppMemoryUsageDecreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MemoryManagerAppMemoryUsageIncreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MemoryManagerAppMemoryUsageLimitChanging => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.System.AppMemoryUsageLimitChangingEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.System.AppMemoryUsageLimitChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging += x, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable UserDeviceAssociationUserDeviceAssociationChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.System.UserDeviceAssociationChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.System.UserDeviceAssociationChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged += x, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged -= x); + } +} + +namespace Windows.System.Power +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BackgroundEnergyManagerRecentEnergyUsageIncreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BackgroundEnergyManagerRecentEnergyUsageReturnedToLow => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ForegroundEnergyManagerRecentEnergyUsageIncreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ForegroundEnergyManagerRecentEnergyUsageReturnedToLow => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerBatteryStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged += x, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged += x, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerPowerSupplyStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged += x, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerRemainingChargePercentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged += x, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerRemainingDischargeTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged += x, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged -= x); + } +} + +namespace Windows.System.Profile +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PlatformDiagnosticsAndUsageDataSettingsCollectionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged += x, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemSetupInfoOutOfBoxExperienceStateChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged += x, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WindowsIntegrityPolicyPolicyChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged += x, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged -= x); + } +} + +namespace Windows.System.Update +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemUpdateManagerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Update.SystemUpdateManager.StateChanged += x, x => global::Windows.System.Update.SystemUpdateManager.StateChanged -= x); + } +} + +namespace Windows.System.UserProfile +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable UserInformationAccountPictureChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.UserProfile.UserInformation.AccountPictureChanged += x, x => global::Windows.System.UserProfile.UserInformation.AccountPictureChanged -= x); + } +} + +namespace Windows.UI.ViewManagement +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ProjectionManagerProjectionDisplayAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged += x, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged -= x); + } +} + +namespace Windows.UI.WebUI +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationActivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs eventArgs) => eventHandler(eventArgs); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.Activated += x, x => global::Windows.UI.WebUI.WebUIApplication.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationBackgroundActivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs eventArgs) => eventHandler(eventArgs); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated += x, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationEnteredBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.IEnteredBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationLeavingBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.ILeavingBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationNavigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.WebUI.IWebUINavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.Navigated += x, x => global::Windows.UI.WebUI.WebUIApplication.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationNewWebUIViewCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.WebUI.NewWebUIViewCreatedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.WebUI.NewWebUIViewCreatedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated += x, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationResuming => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.Resuming += x, x => global::Windows.UI.WebUI.WebUIApplication.Resuming -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationSuspending => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.ISuspendingEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.Suspending += x, x => global::Windows.UI.WebUI.WebUIApplication.Suspending -= x); + } +} + +namespace Windows.UI.Xaml.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AccessKeyManagerIsDisplayModeEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object args) => eventHandler(args); + return Handler; + }, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged += x, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerGettingFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.GettingFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerGotFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.FocusManagerGotFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerGotFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerLosingFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.LosingFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerLostFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.FocusManagerLostFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerLostFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus -= x); + } +} + +namespace Windows.UI.Xaml.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Media.RenderedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Media.RenderedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetSurfaceContentsLost => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/uap10.0.19041.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/uap10.0.19041.approved.txt new file mode 100644 index 0000000..da39641 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/uap10.0.19041.approved.txt @@ -0,0 +1,23957 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Windows.ApplicationModel +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPackageCatalogEvents Events(this global::Windows.ApplicationModel.PackageCatalog item) => new RxPackageCatalogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPackageCatalogEvents + { + private readonly global::Windows.ApplicationModel.PackageCatalog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPackageCatalogEvents(global::Windows.ApplicationModel.PackageCatalog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args)> PackageContentGroupStaging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageContentGroupStaging += x, x => _data.PackageContentGroupStaging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args)> PackageInstalling => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageInstalling += x, x => _data.PackageInstalling -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args)> PackageStaging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageStaging += x, x => _data.PackageStaging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args)> PackageStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args)> PackageUninstalling => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args)> PackageUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + } +} + +namespace Windows.ApplicationModel.Activation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplashScreenEvents Events(this global::Windows.ApplicationModel.Activation.SplashScreen item) => new RxSplashScreenEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplashScreenEvents + { + private readonly global::Windows.ApplicationModel.Activation.SplashScreen _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplashScreenEvents(global::Windows.ApplicationModel.Activation.SplashScreen data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Activation.SplashScreen sender, object args)> Dismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Activation.SplashScreen sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Activation.SplashScreen sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); + } +} + +namespace Windows.ApplicationModel.AppExtensions +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppExtensionCatalogEvents Events(this global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog item) => new RxAppExtensionCatalogEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppExtensionCatalogEvents + { + private readonly global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppExtensionCatalogEvents(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args)> PackageInstalled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageInstalled += x, x => _data.PackageInstalled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args)> PackageStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args)> PackageUninstalling => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args)> PackageUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageUpdated += x, x => _data.PackageUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args)> PackageUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + } +} + +namespace Windows.ApplicationModel.Appointments +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppointmentCalendarSyncManagerEvents Events(this global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager item) => new RxAppointmentCalendarSyncManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppointmentStoreEvents Events(this global::Windows.ApplicationModel.Appointments.AppointmentStore item) => new RxAppointmentStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppointmentCalendarSyncManagerEvents + { + private readonly global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppointmentCalendarSyncManagerEvents(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppointmentStoreEvents + { + private readonly global::Windows.ApplicationModel.Appointments.AppointmentStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppointmentStoreEvents(global::Windows.ApplicationModel.Appointments.AppointmentStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args)> StoreChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + } +} + +namespace Windows.ApplicationModel.Appointments.DataProvider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppointmentDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection item) => new RxAppointmentDataProviderConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppointmentDataProviderConnectionEvents + { + private readonly global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppointmentDataProviderConnectionEvents(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args)> CancelMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CancelMeetingRequested += x, x => _data.CancelMeetingRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args)> CreateOrUpdateAppointmentRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CreateOrUpdateAppointmentRequested += x, x => _data.CreateOrUpdateAppointmentRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args)> ForwardMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args)> ProposeNewTimeForMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args)> SyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args)> UpdateMeetingResponseRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + } +} + +namespace Windows.ApplicationModel.AppService +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppServiceConnectionEvents Events(this global::Windows.ApplicationModel.AppService.AppServiceConnection item) => new RxAppServiceConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppServiceConnectionEvents + { + private readonly global::Windows.ApplicationModel.AppService.AppServiceConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppServiceConnectionEvents(global::Windows.ApplicationModel.AppService.AppServiceConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args)> RequestReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args)> ServiceClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServiceClosed += x, x => _data.ServiceClosed -= x); + } +} + +namespace Windows.ApplicationModel.Background +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBackgroundTaskRegistrationEvents Events(this global::Windows.ApplicationModel.Background.BackgroundTaskRegistration item) => new RxBackgroundTaskRegistrationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBackgroundTaskRegistrationGroupEvents Events(this global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup item) => new RxBackgroundTaskRegistrationGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIBackgroundTaskInstanceEvents Events(this global::Windows.ApplicationModel.Background.IBackgroundTaskInstance item) => new RxIBackgroundTaskInstanceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIBackgroundTaskRegistrationEvents Events(this global::Windows.ApplicationModel.Background.IBackgroundTaskRegistration item) => new RxIBackgroundTaskRegistrationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBackgroundTaskRegistrationEvents + { + private readonly global::Windows.ApplicationModel.Background.BackgroundTaskRegistration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBackgroundTaskRegistrationEvents(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args)> Progress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Progress += x, x => _data.Progress -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBackgroundTaskRegistrationGroupEvents + { + private readonly global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBackgroundTaskRegistrationGroupEvents(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args)> BackgroundActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BackgroundActivated += x, x => _data.BackgroundActivated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIBackgroundTaskInstanceEvents + { + private readonly global::Windows.ApplicationModel.Background.IBackgroundTaskInstance _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIBackgroundTaskInstanceEvents(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason)> Canceled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); + return Handler; + }, x => _data.Canceled += x, x => _data.Canceled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIBackgroundTaskRegistrationEvents + { + private readonly global::Windows.ApplicationModel.Background.IBackgroundTaskRegistration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIBackgroundTaskRegistrationEvents(global::Windows.ApplicationModel.Background.IBackgroundTaskRegistration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args)> Progress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Progress += x, x => _data.Progress -= x); + } +} + +namespace Windows.ApplicationModel.Calls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLockScreenCallUIEvents Events(this global::Windows.ApplicationModel.Calls.LockScreenCallUI item) => new RxLockScreenCallUIEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPhoneLineEvents Events(this global::Windows.ApplicationModel.Calls.PhoneLine item) => new RxPhoneLineEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPhoneLineWatcherEvents Events(this global::Windows.ApplicationModel.Calls.PhoneLineWatcher item) => new RxPhoneLineWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVoipCallCoordinatorEvents Events(this global::Windows.ApplicationModel.Calls.VoipCallCoordinator item) => new RxVoipCallCoordinatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVoipPhoneCallEvents Events(this global::Windows.ApplicationModel.Calls.VoipPhoneCall item) => new RxVoipPhoneCallEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLockScreenCallUIEvents + { + private readonly global::Windows.ApplicationModel.Calls.LockScreenCallUI _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLockScreenCallUIEvents(global::Windows.ApplicationModel.Calls.LockScreenCallUI data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, global::Windows.ApplicationModel.Calls.LockScreenCallEndRequestedEventArgs args)> EndRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, global::Windows.ApplicationModel.Calls.LockScreenCallEndRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.LockScreenCallUI sender, global::Windows.ApplicationModel.Calls.LockScreenCallEndRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EndRequested += x, x => _data.EndRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPhoneLineEvents + { + private readonly global::Windows.ApplicationModel.Calls.PhoneLine _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPhoneLineEvents(global::Windows.ApplicationModel.Calls.PhoneLine data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLine sender, object args)> LineChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLine sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLine sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LineChanged += x, x => _data.LineChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPhoneLineWatcherEvents + { + private readonly global::Windows.ApplicationModel.Calls.PhoneLineWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPhoneLineWatcherEvents(global::Windows.ApplicationModel.Calls.PhoneLineWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)> LineAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LineAdded += x, x => _data.LineAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)> LineRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LineRemoved += x, x => _data.LineRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)> LineUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, global::Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LineUpdated += x, x => _data.LineUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.PhoneLineWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVoipCallCoordinatorEvents + { + private readonly global::Windows.ApplicationModel.Calls.VoipCallCoordinator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVoipCallCoordinatorEvents(global::Windows.ApplicationModel.Calls.VoipCallCoordinator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipCallCoordinator sender, global::Windows.ApplicationModel.Calls.MuteChangeEventArgs args)> MuteStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipCallCoordinator sender, global::Windows.ApplicationModel.Calls.MuteChangeEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipCallCoordinator sender, global::Windows.ApplicationModel.Calls.MuteChangeEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MuteStateChanged += x, x => _data.MuteStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVoipPhoneCallEvents + { + private readonly global::Windows.ApplicationModel.Calls.VoipPhoneCall _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVoipPhoneCallEvents(global::Windows.ApplicationModel.Calls.VoipPhoneCall data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallAnswerEventArgs args)> AnswerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallAnswerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallAnswerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AnswerRequested += x, x => _data.AnswerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)> EndRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EndRequested += x, x => _data.EndRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)> HoldRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HoldRequested += x, x => _data.HoldRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallRejectEventArgs args)> RejectRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallRejectEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallRejectEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RejectRequested += x, x => _data.RejectRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)> ResumeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Calls.VoipPhoneCall sender, global::Windows.ApplicationModel.Calls.CallStateChangeEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResumeRequested += x, x => _data.ResumeRequested -= x); + } +} + +namespace Windows.ApplicationModel.Chat +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxChatConversationEvents Events(this global::Windows.ApplicationModel.Chat.ChatConversation item) => new RxChatConversationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxChatMessageStoreEvents Events(this global::Windows.ApplicationModel.Chat.ChatMessageStore item) => new RxChatMessageStoreEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRcsEndUserMessageManagerEvents Events(this global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager item) => new RxRcsEndUserMessageManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRcsTransportEvents Events(this global::Windows.ApplicationModel.Chat.RcsTransport item) => new RxRcsTransportEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxChatConversationEvents + { + private readonly global::Windows.ApplicationModel.Chat.ChatConversation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxChatConversationEvents(global::Windows.ApplicationModel.Chat.ChatConversation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args)> RemoteParticipantComposingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RemoteParticipantComposingChanged += x, x => _data.RemoteParticipantComposingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxChatMessageStoreEvents + { + private readonly global::Windows.ApplicationModel.Chat.ChatMessageStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxChatMessageStoreEvents(global::Windows.ApplicationModel.Chat.ChatMessageStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args)> MessageChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageChanged += x, x => _data.MessageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args)> StoreChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRcsEndUserMessageManagerEvents + { + private readonly global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRcsEndUserMessageManagerEvents(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args)> MessageAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageAvailableChanged += x, x => _data.MessageAvailableChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRcsTransportEvents + { + private readonly global::Windows.ApplicationModel.Chat.RcsTransport _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRcsTransportEvents(global::Windows.ApplicationModel.Chat.RcsTransport data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args)> ServiceKindSupportedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServiceKindSupportedChanged += x, x => _data.ServiceKindSupportedChanged -= x); + } +} + +namespace Windows.ApplicationModel.Contacts +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactListEvents Events(this global::Windows.ApplicationModel.Contacts.ContactList item) => new RxContactListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactListSyncManagerEvents Events(this global::Windows.ApplicationModel.Contacts.ContactListSyncManager item) => new RxContactListSyncManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactPanelEvents Events(this global::Windows.ApplicationModel.Contacts.ContactPanel item) => new RxContactPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactStoreEvents Events(this global::Windows.ApplicationModel.Contacts.ContactStore item) => new RxContactStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactListEvents + { + private readonly global::Windows.ApplicationModel.Contacts.ContactList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactListEvents(global::Windows.ApplicationModel.Contacts.ContactList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)> ContactChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactListSyncManagerEvents + { + private readonly global::Windows.ApplicationModel.Contacts.ContactListSyncManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactListSyncManagerEvents(global::Windows.ApplicationModel.Contacts.ContactListSyncManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactPanelEvents + { + private readonly global::Windows.ApplicationModel.Contacts.ContactPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactPanelEvents(global::Windows.ApplicationModel.Contacts.ContactPanel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args)> LaunchFullAppRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LaunchFullAppRequested += x, x => _data.LaunchFullAppRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactStoreEvents + { + private readonly global::Windows.ApplicationModel.Contacts.ContactStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactStoreEvents(global::Windows.ApplicationModel.Contacts.ContactStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)> ContactChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + } +} + +namespace Windows.ApplicationModel.Contacts.DataProvider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection item) => new RxContactDataProviderConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactDataProviderConnectionEvents + { + private readonly global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactDataProviderConnectionEvents(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args)> CreateOrUpdateContactRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CreateOrUpdateContactRequested += x, x => _data.CreateOrUpdateContactRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args)> DeleteContactRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DeleteContactRequested += x, x => _data.DeleteContactRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args)> ServerSearchReadBatchRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args)> SyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + } +} + +namespace Windows.ApplicationModel.Contacts.Provider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContactPickerUIEvents Events(this global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI item) => new RxContactPickerUIEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContactPickerUIEvents + { + private readonly global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContactPickerUIEvents(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args)> ContactRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContactRemoved += x, x => _data.ContactRemoved -= x); + } +} + +namespace Windows.ApplicationModel.ConversationalAgent +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxActivationSignalDetectionConfigurationEvents Events(this global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration item) => new RxActivationSignalDetectionConfigurationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxConversationalAgentSessionEvents Events(this global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession item) => new RxConversationalAgentSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxActivationSignalDetectionConfigurationEvents + { + private readonly global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxActivationSignalDetectionConfigurationEvents(global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration sender, global::Windows.ApplicationModel.ConversationalAgent.DetectionConfigurationAvailabilityChangedEventArgs args)> AvailabilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration sender, global::Windows.ApplicationModel.ConversationalAgent.DetectionConfigurationAvailabilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration sender, global::Windows.ApplicationModel.ConversationalAgent.DetectionConfigurationAvailabilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxConversationalAgentSessionEvents + { + private readonly global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxConversationalAgentSessionEvents(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSessionInterruptedEventArgs args)> SessionInterrupted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSessionInterruptedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSessionInterruptedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionInterrupted += x, x => _data.SessionInterrupted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSignalDetectedEventArgs args)> SignalDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSignalDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSignalDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SignalDetected += x, x => _data.SignalDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSystemStateChangedEventArgs args)> SystemStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSystemStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession sender, global::Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSystemStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemStateChanged += x, x => _data.SystemStateChanged -= x); + } +} + +namespace Windows.ApplicationModel.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreApplicationViewEvents Events(this global::Windows.ApplicationModel.Core.CoreApplicationView item) => new RxCoreApplicationViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreApplicationViewTitleBarEvents Events(this global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar item) => new RxCoreApplicationViewTitleBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICoreApplicationUnhandledErrorEvents Events(this global::Windows.ApplicationModel.Core.ICoreApplicationUnhandledError item) => new RxICoreApplicationUnhandledErrorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreApplicationViewEvents + { + private readonly global::Windows.ApplicationModel.Core.CoreApplicationView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreApplicationViewEvents(global::Windows.ApplicationModel.Core.CoreApplicationView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args)> HostedViewClosing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HostedViewClosing += x, x => _data.HostedViewClosing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreApplicationViewTitleBarEvents + { + private readonly global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreApplicationViewTitleBarEvents(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)> IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)> LayoutMetricsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LayoutMetricsChanged += x, x => _data.LayoutMetricsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICoreApplicationUnhandledErrorEvents + { + private readonly global::Windows.ApplicationModel.Core.ICoreApplicationUnhandledError _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICoreApplicationUnhandledErrorEvents(global::Windows.ApplicationModel.Core.ICoreApplicationUnhandledError data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledErrorDetected => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledErrorDetected += x, x => _data.UnhandledErrorDetected -= x); + } +} + +namespace Windows.ApplicationModel.DataTransfer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataPackageEvents Events(this global::Windows.ApplicationModel.DataTransfer.DataPackage item) => new RxDataPackageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDataTransferManagerEvents Events(this global::Windows.ApplicationModel.DataTransfer.DataTransferManager item) => new RxDataTransferManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataPackageEvents + { + private readonly global::Windows.ApplicationModel.DataTransfer.DataPackage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataPackageEvents(global::Windows.ApplicationModel.DataTransfer.DataPackage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args)> Destroyed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args)> OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args)> ShareCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShareCanceled += x, x => _data.ShareCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args)> ShareCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShareCompleted += x, x => _data.ShareCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDataTransferManagerEvents + { + private readonly global::Windows.ApplicationModel.DataTransfer.DataTransferManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDataTransferManagerEvents(global::Windows.ApplicationModel.DataTransfer.DataTransferManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args)> DataRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataRequested += x, x => _data.DataRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args)> ShareProvidersRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShareProvidersRequested += x, x => _data.ShareProvidersRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args)> TargetApplicationChosen => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TargetApplicationChosen += x, x => _data.TargetApplicationChosen -= x); + } +} + +namespace Windows.ApplicationModel.DataTransfer.DragDrop.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreDragDropManagerEvents Events(this global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager item) => new RxCoreDragDropManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreDragDropManagerEvents + { + private readonly global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreDragDropManagerEvents(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args)> TargetRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TargetRequested += x, x => _data.TargetRequested -= x); + } +} + +namespace Windows.ApplicationModel.Email +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEmailMailboxEvents Events(this global::Windows.ApplicationModel.Email.EmailMailbox item) => new RxEmailMailboxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEmailMailboxSyncManagerEvents Events(this global::Windows.ApplicationModel.Email.EmailMailboxSyncManager item) => new RxEmailMailboxSyncManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEmailMailboxEvents + { + private readonly global::Windows.ApplicationModel.Email.EmailMailbox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEmailMailboxEvents(global::Windows.ApplicationModel.Email.EmailMailbox data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args)> MailboxChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MailboxChanged += x, x => _data.MailboxChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEmailMailboxSyncManagerEvents + { + private readonly global::Windows.ApplicationModel.Email.EmailMailboxSyncManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEmailMailboxSyncManagerEvents(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + } +} + +namespace Windows.ApplicationModel.Email.DataProvider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEmailDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection item) => new RxEmailDataProviderConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEmailDataProviderConnectionEvents + { + private readonly global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEmailDataProviderConnectionEvents(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args)> CreateFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CreateFolderRequested += x, x => _data.CreateFolderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args)> DeleteFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DeleteFolderRequested += x, x => _data.DeleteFolderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args)> DownloadAttachmentRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadAttachmentRequested += x, x => _data.DownloadAttachmentRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args)> DownloadMessageRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadMessageRequested += x, x => _data.DownloadMessageRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args)> EmptyFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EmptyFolderRequested += x, x => _data.EmptyFolderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args)> ForwardMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args)> GetAutoReplySettingsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GetAutoReplySettingsRequested += x, x => _data.GetAutoReplySettingsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args)> MailboxSyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MailboxSyncRequested += x, x => _data.MailboxSyncRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args)> MoveFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MoveFolderRequested += x, x => _data.MoveFolderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args)> ProposeNewTimeForMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args)> ResolveRecipientsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResolveRecipientsRequested += x, x => _data.ResolveRecipientsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args)> ServerSearchReadBatchRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args)> SetAutoReplySettingsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SetAutoReplySettingsRequested += x, x => _data.SetAutoReplySettingsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args)> UpdateMeetingResponseRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args)> ValidateCertificatesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValidateCertificatesRequested += x, x => _data.ValidateCertificatesRequested -= x); + } +} + +namespace Windows.ApplicationModel.ExtendedExecution +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExtendedExecutionSessionEvents Events(this global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionSession item) => new RxExtendedExecutionSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExtendedExecutionSessionEvents + { + private readonly global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExtendedExecutionSessionEvents(global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Revoked => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionRevokedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionRevokedEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.Revoked += x, x => _data.Revoked -= x); + } +} + +namespace Windows.ApplicationModel.ExtendedExecution.Foreground +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExtendedExecutionForegroundSessionEvents Events(this global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundSession item) => new RxExtendedExecutionForegroundSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExtendedExecutionForegroundSessionEvents + { + private readonly global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExtendedExecutionForegroundSessionEvents(global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Revoked => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundRevokedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundRevokedEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.Revoked += x, x => _data.Revoked -= x); + } +} + +namespace Windows.ApplicationModel.LockScreen +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLockApplicationHostEvents Events(this global::Windows.ApplicationModel.LockScreen.LockApplicationHost item) => new RxLockApplicationHostEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLockScreenInfoEvents Events(this global::Windows.ApplicationModel.LockScreen.LockScreenInfo item) => new RxLockScreenInfoEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLockApplicationHostEvents + { + private readonly global::Windows.ApplicationModel.LockScreen.LockApplicationHost _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLockApplicationHostEvents(global::Windows.ApplicationModel.LockScreen.LockApplicationHost data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args)> Unlocking => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Unlocking += x, x => _data.Unlocking -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLockScreenInfoEvents + { + private readonly global::Windows.ApplicationModel.LockScreen.LockScreenInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLockScreenInfoEvents(global::Windows.ApplicationModel.LockScreen.LockScreenInfo data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> AlarmIconChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AlarmIconChanged += x, x => _data.AlarmIconChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> BadgesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BadgesChanged += x, x => _data.BadgesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> DetailTextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DetailTextChanged += x, x => _data.DetailTextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> LockScreenImageChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LockScreenImageChanged += x, x => _data.LockScreenImageChanged -= x); + } +} + +namespace Windows.ApplicationModel.Preview.Notes +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNotesWindowManagerPreviewEvents Events(this global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview item) => new RxNotesWindowManagerPreviewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNotesWindowManagerPreviewEvents + { + private readonly global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNotesWindowManagerPreviewEvents(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NotePlacementChangedPreviewEventArgs args)> NotePlacementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NotePlacementChangedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NotePlacementChangedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NotePlacementChanged += x, x => _data.NotePlacementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NoteVisibilityChangedPreviewEventArgs args)> NoteVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NoteVisibilityChangedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, global::Windows.ApplicationModel.Preview.Notes.NoteVisibilityChangedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NoteVisibilityChanged += x, x => _data.NoteVisibilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, object args)> SystemLockStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemLockStateChanged += x, x => _data.SystemLockStateChanged -= x); + } +} + +namespace Windows.ApplicationModel.Resources.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxResourceQualifierObservableMapEvents Events(this global::Windows.ApplicationModel.Resources.Core.ResourceQualifierObservableMap item) => new RxResourceQualifierObservableMapEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxResourceQualifierObservableMapEvents + { + private readonly global::Windows.ApplicationModel.Resources.Core.ResourceQualifierObservableMap _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxResourceQualifierObservableMapEvents(global::Windows.ApplicationModel.Resources.Core.ResourceQualifierObservableMap data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } +} + +namespace Windows.ApplicationModel.Search +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSearchPaneEvents Events(this global::Windows.ApplicationModel.Search.SearchPane item) => new RxSearchPaneEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSearchPaneEvents + { + private readonly global::Windows.ApplicationModel.Search.SearchPane _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSearchPaneEvents(global::Windows.ApplicationModel.Search.SearchPane data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQueryChangedEventArgs args)> QueryChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQueryChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQueryChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QueryChanged += x, x => _data.QueryChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQuerySubmittedEventArgs args)> QuerySubmitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQuerySubmittedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneQuerySubmittedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneResultSuggestionChosenEventArgs args)> ResultSuggestionChosen => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneResultSuggestionChosenEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneResultSuggestionChosenEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneSuggestionsRequestedEventArgs args)> SuggestionsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneSuggestionsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneSuggestionsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneVisibilityChangedEventArgs args)> VisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneVisibilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.SearchPane sender, global::Windows.ApplicationModel.Search.SearchPaneVisibilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + } +} + +namespace Windows.ApplicationModel.Search.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSearchSuggestionManagerEvents Events(this global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager item) => new RxSearchSuggestionManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSearchSuggestionManagerEvents + { + private readonly global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSearchSuggestionManagerEvents(global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.RequestingFocusOnKeyboardInputEventArgs args)> RequestingFocusOnKeyboardInput => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.RequestingFocusOnKeyboardInputEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.RequestingFocusOnKeyboardInputEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RequestingFocusOnKeyboardInput += x, x => _data.RequestingFocusOnKeyboardInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.SearchSuggestionsRequestedEventArgs args)> SuggestionsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.SearchSuggestionsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Search.Core.SearchSuggestionManager sender, global::Windows.ApplicationModel.Search.Core.SearchSuggestionsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); + } +} + +namespace Windows.ApplicationModel.Store +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLicenseInformationEvents Events(this global::Windows.ApplicationModel.Store.LicenseInformation item) => new RxLicenseInformationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLicenseInformationEvents + { + private readonly global::Windows.ApplicationModel.Store.LicenseInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLicenseInformationEvents(global::Windows.ApplicationModel.Store.LicenseInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LicenseChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler() => eventHandler(global::System.Reactive.Unit.Default); + return Handler; + }, x => _data.LicenseChanged += x, x => _data.LicenseChanged -= x); + } +} + +namespace Windows.ApplicationModel.Store.Preview.InstallControl +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppInstallItemEvents Events(this global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem item) => new RxAppInstallItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppInstallManagerEvents Events(this global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager item) => new RxAppInstallManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppInstallItemEvents + { + private readonly global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppInstallItemEvents(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppInstallManagerEvents + { + private readonly global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppInstallManagerEvents(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)> ItemCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemCompleted += x, x => _data.ItemCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)> ItemStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemStatusChanged += x, x => _data.ItemStatusChanged -= x); + } +} + +namespace Windows.ApplicationModel.UserActivities +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserActivityRequestManagerEvents Events(this global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager item) => new RxUserActivityRequestManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserActivityRequestManagerEvents + { + private readonly global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserActivityRequestManagerEvents(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args)> UserActivityRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserActivityRequested += x, x => _data.UserActivityRequested -= x); + } +} + +namespace Windows.ApplicationModel.UserDataAccounts +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserDataAccountStoreEvents Events(this global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore item) => new RxUserDataAccountStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserDataAccountStoreEvents + { + private readonly global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserDataAccountStoreEvents(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args)> StoreChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + } +} + +namespace Windows.ApplicationModel.UserDataTasks +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserDataTaskListSyncManagerEvents Events(this global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager item) => new RxUserDataTaskListSyncManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserDataTaskListSyncManagerEvents + { + private readonly global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserDataTaskListSyncManagerEvents(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + } +} + +namespace Windows.ApplicationModel.UserDataTasks.DataProvider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserDataTaskDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection item) => new RxUserDataTaskDataProviderConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserDataTaskDataProviderConnectionEvents + { + private readonly global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserDataTaskDataProviderConnectionEvents(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args)> CompleteTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CompleteTaskRequested += x, x => _data.CompleteTaskRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args)> CreateOrUpdateTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CreateOrUpdateTaskRequested += x, x => _data.CreateOrUpdateTaskRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args)> DeleteTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DeleteTaskRequested += x, x => _data.DeleteTaskRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args)> SkipOccurrenceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SkipOccurrenceRequested += x, x => _data.SkipOccurrenceRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args)> SyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + } +} + +namespace Windows.ApplicationModel.VoiceCommands +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVoiceCommandServiceConnectionEvents Events(this global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection item) => new RxVoiceCommandServiceConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVoiceCommandServiceConnectionEvents + { + private readonly global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVoiceCommandServiceConnectionEvents(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args)> VoiceCommandCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VoiceCommandCompleted += x, x => _data.VoiceCommandCompleted -= x); + } +} + +namespace Windows.ApplicationModel.Wallet.System +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWalletItemSystemStoreEvents Events(this global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore item) => new RxWalletItemSystemStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWalletItemSystemStoreEvents + { + private readonly global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWalletItemSystemStoreEvents(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args)> ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args)>(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + } +} + +namespace Windows.Devices.AllJoyn +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAllJoynBusAttachmentEvents Events(this global::Windows.Devices.AllJoyn.AllJoynBusAttachment item) => new RxAllJoynBusAttachmentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAllJoynBusObjectEvents Events(this global::Windows.Devices.AllJoyn.AllJoynBusObject item) => new RxAllJoynBusObjectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAllJoynSessionEvents Events(this global::Windows.Devices.AllJoyn.AllJoynSession item) => new RxAllJoynSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAllJoynBusAttachmentEvents + { + private readonly global::Windows.Devices.AllJoyn.AllJoynBusAttachment _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAllJoynBusAttachmentEvents(global::Windows.Devices.AllJoyn.AllJoynBusAttachment data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args)> AcceptSessionJoinerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AcceptSessionJoinerRequested += x, x => _data.AcceptSessionJoinerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args)> AuthenticationComplete => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AuthenticationComplete += x, x => _data.AuthenticationComplete -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args)> CredentialsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CredentialsRequested += x, x => _data.CredentialsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args)> CredentialsVerificationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CredentialsVerificationRequested += x, x => _data.CredentialsVerificationRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args)> SessionJoined => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionJoined += x, x => _data.SessionJoined -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAllJoynBusObjectEvents + { + private readonly global::Windows.Devices.AllJoyn.AllJoynBusObject _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAllJoynBusObjectEvents(global::Windows.Devices.AllJoyn.AllJoynBusObject data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAllJoynSessionEvents + { + private readonly global::Windows.Devices.AllJoyn.AllJoynSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAllJoynSessionEvents(global::Windows.Devices.AllJoyn.AllJoynSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args)> Lost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Lost += x, x => _data.Lost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args)> MemberAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MemberAdded += x, x => _data.MemberAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args)> MemberRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MemberRemoved += x, x => _data.MemberRemoved -= x); + } +} + +namespace Windows.Devices.Bluetooth +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBluetoothDeviceEvents Events(this global::Windows.Devices.Bluetooth.BluetoothDevice item) => new RxBluetoothDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBluetoothLEDeviceEvents Events(this global::Windows.Devices.Bluetooth.BluetoothLEDevice item) => new RxBluetoothLEDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBluetoothDeviceEvents + { + private readonly global::Windows.Devices.Bluetooth.BluetoothDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBluetoothDeviceEvents(global::Windows.Devices.Bluetooth.BluetoothDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)> ConnectionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)> NameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)> SdpRecordsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SdpRecordsChanged += x, x => _data.SdpRecordsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBluetoothLEDeviceEvents + { + private readonly global::Windows.Devices.Bluetooth.BluetoothLEDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBluetoothLEDeviceEvents(global::Windows.Devices.Bluetooth.BluetoothLEDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)> ConnectionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)> GattServicesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GattServicesChanged += x, x => _data.GattServicesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)> NameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); + } +} + +namespace Windows.Devices.Bluetooth.Advertisement +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBluetoothLEAdvertisementPublisherEvents Events(this global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher item) => new RxBluetoothLEAdvertisementPublisherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBluetoothLEAdvertisementWatcherEvents Events(this global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher item) => new RxBluetoothLEAdvertisementWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBluetoothLEAdvertisementPublisherEvents + { + private readonly global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBluetoothLEAdvertisementPublisherEvents(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBluetoothLEAdvertisementWatcherEvents + { + private readonly global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBluetoothLEAdvertisementWatcherEvents(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args)> Received => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Received += x, x => _data.Received -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } +} + +namespace Windows.Devices.Bluetooth.GenericAttributeProfile +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattCharacteristicEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic item) => new RxGattCharacteristicEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattLocalCharacteristicEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic item) => new RxGattLocalCharacteristicEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattLocalDescriptorEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor item) => new RxGattLocalDescriptorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattReadRequestEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest item) => new RxGattReadRequestEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattServiceProviderEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider item) => new RxGattServiceProviderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattSessionEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession item) => new RxGattSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattSubscribedClientEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient item) => new RxGattSubscribedClientEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGattWriteRequestEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest item) => new RxGattWriteRequestEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattCharacteristicEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattCharacteristicEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args)> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattLocalCharacteristicEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattLocalCharacteristicEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)> ReadRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args)> SubscribedClientsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SubscribedClientsChanged += x, x => _data.SubscribedClientsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)> WriteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattLocalDescriptorEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattLocalDescriptorEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)> ReadRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)> WriteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattReadRequestEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattReadRequestEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattServiceProviderEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattServiceProviderEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args)> AdvertisementStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattSessionEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattSessionEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args)> MaxPduSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MaxPduSizeChanged += x, x => _data.MaxPduSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args)> SessionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattSubscribedClientEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattSubscribedClientEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args)> MaxNotificationSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MaxNotificationSizeChanged += x, x => _data.MaxNotificationSizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGattWriteRequestEvents + { + private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGattWriteRequestEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace Windows.Devices.Display.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDisplayManagerEvents Events(this global::Windows.Devices.Display.Core.DisplayManager item) => new RxDisplayManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDisplayManagerEvents + { + private readonly global::Windows.Devices.Display.Core.DisplayManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDisplayManagerEvents(global::Windows.Devices.Display.Core.DisplayManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args)> Disabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Disabled += x, x => _data.Disabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args)> Enabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Enabled += x, x => _data.Enabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args)> PathsFailedOrInvalidated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PathsFailedOrInvalidated += x, x => _data.PathsFailedOrInvalidated -= x); + } +} + +namespace Windows.Devices.Enumeration +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDeviceAccessInformationEvents Events(this global::Windows.Devices.Enumeration.DeviceAccessInformation item) => new RxDeviceAccessInformationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDeviceInformationCustomPairingEvents Events(this global::Windows.Devices.Enumeration.DeviceInformationCustomPairing item) => new RxDeviceInformationCustomPairingEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDevicePickerEvents Events(this global::Windows.Devices.Enumeration.DevicePicker item) => new RxDevicePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDeviceWatcherEvents Events(this global::Windows.Devices.Enumeration.DeviceWatcher item) => new RxDeviceWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDeviceAccessInformationEvents + { + private readonly global::Windows.Devices.Enumeration.DeviceAccessInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDeviceAccessInformationEvents(global::Windows.Devices.Enumeration.DeviceAccessInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args)> AccessChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessChanged += x, x => _data.AccessChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDeviceInformationCustomPairingEvents + { + private readonly global::Windows.Devices.Enumeration.DeviceInformationCustomPairing _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDeviceInformationCustomPairingEvents(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args)> PairingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PairingRequested += x, x => _data.PairingRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDevicePickerEvents + { + private readonly global::Windows.Devices.Enumeration.DevicePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDevicePickerEvents(global::Windows.Devices.Enumeration.DevicePicker data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DevicePicker sender, object args)> DevicePickerDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DevicePicker sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DevicePickerDismissed += x, x => _data.DevicePickerDismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args)> DeviceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DeviceSelected += x, x => _data.DeviceSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args)> DisconnectButtonClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDeviceWatcherEvents + { + private readonly global::Windows.Devices.Enumeration.DeviceWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDeviceWatcherEvents(global::Windows.Devices.Enumeration.DeviceWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace Windows.Devices.Enumeration.Pnp +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPnpObjectWatcherEvents Events(this global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher item) => new RxPnpObjectWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPnpObjectWatcherEvents + { + private readonly global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPnpObjectWatcherEvents(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)>(eventHandler => + { + void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace Windows.Devices.Geolocation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGeolocatorEvents Events(this global::Windows.Devices.Geolocation.Geolocator item) => new RxGeolocatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGeovisitMonitorEvents Events(this global::Windows.Devices.Geolocation.GeovisitMonitor item) => new RxGeovisitMonitorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGeolocatorEvents + { + private readonly global::Windows.Devices.Geolocation.Geolocator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGeolocatorEvents(global::Windows.Devices.Geolocation.Geolocator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args)> PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGeovisitMonitorEvents + { + private readonly global::Windows.Devices.Geolocation.GeovisitMonitor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGeovisitMonitorEvents(global::Windows.Devices.Geolocation.GeovisitMonitor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args)> VisitStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisitStateChanged += x, x => _data.VisitStateChanged -= x); + } +} + +namespace Windows.Devices.Geolocation.Geofencing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGeofenceMonitorEvents Events(this global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor item) => new RxGeofenceMonitorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGeofenceMonitorEvents + { + private readonly global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGeofenceMonitorEvents(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)> GeofenceStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GeofenceStateChanged += x, x => _data.GeofenceStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } +} + +namespace Windows.Devices.Gpio +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGpioPinEvents Events(this global::Windows.Devices.Gpio.GpioPin item) => new RxGpioPinEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGpioPinEvents + { + private readonly global::Windows.Devices.Gpio.GpioPin _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGpioPinEvents(global::Windows.Devices.Gpio.GpioPin data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Gpio.GpioPin sender, global::Windows.Devices.Gpio.GpioPinValueChangedEventArgs args)> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Gpio.GpioPin sender, global::Windows.Devices.Gpio.GpioPinValueChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Gpio.GpioPin sender, global::Windows.Devices.Gpio.GpioPinValueChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } +} + +namespace Windows.Devices.Gpio.Provider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIGpioPinProviderEvents Events(this global::Windows.Devices.Gpio.Provider.IGpioPinProvider item) => new RxIGpioPinProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIGpioPinProviderEvents + { + private readonly global::Windows.Devices.Gpio.Provider.IGpioPinProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIGpioPinProviderEvents(global::Windows.Devices.Gpio.Provider.IGpioPinProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Gpio.Provider.IGpioPinProvider sender, global::Windows.Devices.Gpio.Provider.GpioPinProviderValueChangedEventArgs args)> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Gpio.Provider.IGpioPinProvider sender, global::Windows.Devices.Gpio.Provider.GpioPinProviderValueChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Gpio.Provider.IGpioPinProvider sender, global::Windows.Devices.Gpio.Provider.GpioPinProviderValueChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } +} + +namespace Windows.Devices.HumanInterfaceDevice +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHidDeviceEvents Events(this global::Windows.Devices.HumanInterfaceDevice.HidDevice item) => new RxHidDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHidDeviceEvents + { + private readonly global::Windows.Devices.HumanInterfaceDevice.HidDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHidDeviceEvents(global::Windows.Devices.HumanInterfaceDevice.HidDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args)> InputReportReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InputReportReceived += x, x => _data.InputReportReceived -= x); + } +} + +namespace Windows.Devices.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMouseDeviceEvents Events(this global::Windows.Devices.Input.MouseDevice item) => new RxMouseDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPenButtonListenerEvents Events(this global::Windows.Devices.Input.PenButtonListener item) => new RxPenButtonListenerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPenDockListenerEvents Events(this global::Windows.Devices.Input.PenDockListener item) => new RxPenDockListenerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMouseDeviceEvents + { + private readonly global::Windows.Devices.Input.MouseDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMouseDeviceEvents(global::Windows.Devices.Input.MouseDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args)> MouseMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MouseMoved += x, x => _data.MouseMoved -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPenButtonListenerEvents + { + private readonly global::Windows.Devices.Input.PenButtonListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPenButtonListenerEvents(global::Windows.Devices.Input.PenButtonListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenButtonListener sender, object args)> IsSupportedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenButtonListener sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenButtonListener sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonClickedEventArgs args)> TailButtonClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonClickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonClickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TailButtonClicked += x, x => _data.TailButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonDoubleClickedEventArgs args)> TailButtonDoubleClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonDoubleClickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonDoubleClickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TailButtonDoubleClicked += x, x => _data.TailButtonDoubleClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonLongPressedEventArgs args)> TailButtonLongPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonLongPressedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenButtonListener sender, global::Windows.Devices.Input.PenTailButtonLongPressedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TailButtonLongPressed += x, x => _data.TailButtonLongPressed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPenDockListenerEvents + { + private readonly global::Windows.Devices.Input.PenDockListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPenDockListenerEvents(global::Windows.Devices.Input.PenDockListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenDockedEventArgs args)> Docked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenDockedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenDockedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Docked += x, x => _data.Docked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenDockListener sender, object args)> IsSupportedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenDockListener sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenDockListener sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenUndockedEventArgs args)> Undocked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenUndockedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.PenDockListener sender, global::Windows.Devices.Input.PenUndockedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Undocked += x, x => _data.Undocked -= x); + } +} + +namespace Windows.Devices.Input.Preview +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGazeDeviceWatcherPreviewEvents Events(this global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview item) => new RxGazeDeviceWatcherPreviewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGazeInputSourcePreviewEvents Events(this global::Windows.Devices.Input.Preview.GazeInputSourcePreview item) => new RxGazeInputSourcePreviewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGazeDeviceWatcherPreviewEvents + { + private readonly global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGazeDeviceWatcherPreviewEvents(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGazeInputSourcePreviewEvents + { + private readonly global::Windows.Devices.Input.Preview.GazeInputSourcePreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGazeInputSourcePreviewEvents(global::Windows.Devices.Input.Preview.GazeInputSourcePreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args)> GazeEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GazeEntered += x, x => _data.GazeEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args)> GazeExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GazeExited += x, x => _data.GazeExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args)> GazeMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GazeMoved += x, x => _data.GazeMoved -= x); + } +} + +namespace Windows.Devices.Lights +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLampEvents Events(this global::Windows.Devices.Lights.Lamp item) => new RxLampEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLampEvents + { + private readonly global::Windows.Devices.Lights.Lamp _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLampEvents(global::Windows.Devices.Lights.Lamp data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args)> AvailabilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); + } +} + +namespace Windows.Devices.Lights.Effects +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLampArrayBitmapEffectEvents Events(this global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect item) => new RxLampArrayBitmapEffectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLampArrayCustomEffectEvents Events(this global::Windows.Devices.Lights.Effects.LampArrayCustomEffect item) => new RxLampArrayCustomEffectEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLampArrayBitmapEffectEvents + { + private readonly global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLampArrayBitmapEffectEvents(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args)> BitmapRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLampArrayCustomEffectEvents + { + private readonly global::Windows.Devices.Lights.Effects.LampArrayCustomEffect _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLampArrayCustomEffectEvents(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args)> UpdateRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UpdateRequested += x, x => _data.UpdateRequested -= x); + } +} + +namespace Windows.Devices.Midi +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMidiInPortEvents Events(this global::Windows.Devices.Midi.MidiInPort item) => new RxMidiInPortEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMidiInPortEvents + { + private readonly global::Windows.Devices.Midi.MidiInPort _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMidiInPortEvents(global::Windows.Devices.Midi.MidiInPort data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } +} + +namespace Windows.Devices.Perception +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionColorFrameReaderEvents Events(this global::Windows.Devices.Perception.PerceptionColorFrameReader item) => new RxPerceptionColorFrameReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionColorFrameSourceEvents Events(this global::Windows.Devices.Perception.PerceptionColorFrameSource item) => new RxPerceptionColorFrameSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionColorFrameSourceWatcherEvents Events(this global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher item) => new RxPerceptionColorFrameSourceWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionControlSessionEvents Events(this global::Windows.Devices.Perception.PerceptionControlSession item) => new RxPerceptionControlSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionDepthFrameReaderEvents Events(this global::Windows.Devices.Perception.PerceptionDepthFrameReader item) => new RxPerceptionDepthFrameReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionDepthFrameSourceEvents Events(this global::Windows.Devices.Perception.PerceptionDepthFrameSource item) => new RxPerceptionDepthFrameSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionDepthFrameSourceWatcherEvents Events(this global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher item) => new RxPerceptionDepthFrameSourceWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionInfraredFrameReaderEvents Events(this global::Windows.Devices.Perception.PerceptionInfraredFrameReader item) => new RxPerceptionInfraredFrameReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionInfraredFrameSourceEvents Events(this global::Windows.Devices.Perception.PerceptionInfraredFrameSource item) => new RxPerceptionInfraredFrameSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPerceptionInfraredFrameSourceWatcherEvents Events(this global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher item) => new RxPerceptionInfraredFrameSourceWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionColorFrameReaderEvents + { + private readonly global::Windows.Devices.Perception.PerceptionColorFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionColorFrameReaderEvents(global::Windows.Devices.Perception.PerceptionColorFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionColorFrameSourceEvents + { + private readonly global::Windows.Devices.Perception.PerceptionColorFrameSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionColorFrameSourceEvents(global::Windows.Devices.Perception.PerceptionColorFrameSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> ActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> CameraIntrinsicsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)> PropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> VideoProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionColorFrameSourceWatcherEvents + { + private readonly global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionColorFrameSourceWatcherEvents(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args)> SourceAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args)> SourceRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionControlSessionEvents + { + private readonly global::Windows.Devices.Perception.PerceptionControlSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionControlSessionEvents(global::Windows.Devices.Perception.PerceptionControlSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionControlSession sender, object args)> ControlLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionControlSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionControlSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionDepthFrameReaderEvents + { + private readonly global::Windows.Devices.Perception.PerceptionDepthFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionDepthFrameReaderEvents(global::Windows.Devices.Perception.PerceptionDepthFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionDepthFrameSourceEvents + { + private readonly global::Windows.Devices.Perception.PerceptionDepthFrameSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionDepthFrameSourceEvents(global::Windows.Devices.Perception.PerceptionDepthFrameSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> ActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> CameraIntrinsicsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)> PropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> VideoProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionDepthFrameSourceWatcherEvents + { + private readonly global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionDepthFrameSourceWatcherEvents(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args)> SourceAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args)> SourceRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionInfraredFrameReaderEvents + { + private readonly global::Windows.Devices.Perception.PerceptionInfraredFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionInfraredFrameReaderEvents(global::Windows.Devices.Perception.PerceptionInfraredFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionInfraredFrameSourceEvents + { + private readonly global::Windows.Devices.Perception.PerceptionInfraredFrameSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionInfraredFrameSourceEvents(global::Windows.Devices.Perception.PerceptionInfraredFrameSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> ActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> CameraIntrinsicsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)> PropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> VideoProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPerceptionInfraredFrameSourceWatcherEvents + { + private readonly global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPerceptionInfraredFrameSourceWatcherEvents(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args)> SourceAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args)> SourceRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } +} + +namespace Windows.Devices.PointOfService +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBarcodeScannerEvents Events(this global::Windows.Devices.PointOfService.BarcodeScanner item) => new RxBarcodeScannerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCashDrawerEvents Events(this global::Windows.Devices.PointOfService.CashDrawer item) => new RxCashDrawerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCashDrawerCloseAlarmEvents Events(this global::Windows.Devices.PointOfService.CashDrawerCloseAlarm item) => new RxCashDrawerCloseAlarmEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCashDrawerEventSourceEvents Events(this global::Windows.Devices.PointOfService.CashDrawerEventSource item) => new RxCashDrawerEventSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClaimedBarcodeScannerEvents Events(this global::Windows.Devices.PointOfService.ClaimedBarcodeScanner item) => new RxClaimedBarcodeScannerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClaimedCashDrawerEvents Events(this global::Windows.Devices.PointOfService.ClaimedCashDrawer item) => new RxClaimedCashDrawerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClaimedLineDisplayEvents Events(this global::Windows.Devices.PointOfService.ClaimedLineDisplay item) => new RxClaimedLineDisplayEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClaimedMagneticStripeReaderEvents Events(this global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader item) => new RxClaimedMagneticStripeReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxClaimedPosPrinterEvents Events(this global::Windows.Devices.PointOfService.ClaimedPosPrinter item) => new RxClaimedPosPrinterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMagneticStripeReaderEvents Events(this global::Windows.Devices.PointOfService.MagneticStripeReader item) => new RxMagneticStripeReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPosPrinterEvents Events(this global::Windows.Devices.PointOfService.PosPrinter item) => new RxPosPrinterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBarcodeScannerEvents + { + private readonly global::Windows.Devices.PointOfService.BarcodeScanner _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBarcodeScannerEvents(global::Windows.Devices.PointOfService.BarcodeScanner data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCashDrawerEvents + { + private readonly global::Windows.Devices.PointOfService.CashDrawer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCashDrawerEvents(global::Windows.Devices.PointOfService.CashDrawer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCashDrawerCloseAlarmEvents + { + private readonly global::Windows.Devices.PointOfService.CashDrawerCloseAlarm _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCashDrawerCloseAlarmEvents(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args)> AlarmTimeoutExpired => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AlarmTimeoutExpired += x, x => _data.AlarmTimeoutExpired -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCashDrawerEventSourceEvents + { + private readonly global::Windows.Devices.PointOfService.CashDrawerEventSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCashDrawerEventSourceEvents(global::Windows.Devices.PointOfService.CashDrawerEventSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args)> DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args)> DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClaimedBarcodeScannerEvents + { + private readonly global::Windows.Devices.PointOfService.ClaimedBarcodeScanner _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClaimedBarcodeScannerEvents(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args)> DataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args)> ImagePreviewReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ImagePreviewReceived += x, x => _data.ImagePreviewReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner>(eventHandler => + { + void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); + return Handler; + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TriggerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner>(eventHandler => + { + void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); + return Handler; + }, x => _data.TriggerPressed += x, x => _data.TriggerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TriggerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner>(eventHandler => + { + void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); + return Handler; + }, x => _data.TriggerReleased += x, x => _data.TriggerReleased -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClaimedCashDrawerEvents + { + private readonly global::Windows.Devices.PointOfService.ClaimedCashDrawer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClaimedCashDrawerEvents(global::Windows.Devices.PointOfService.ClaimedCashDrawer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args)> ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClaimedLineDisplayEvents + { + private readonly global::Windows.Devices.PointOfService.ClaimedLineDisplay _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClaimedLineDisplayEvents(global::Windows.Devices.PointOfService.ClaimedLineDisplay data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args)> ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClaimedMagneticStripeReaderEvents + { + private readonly global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClaimedMagneticStripeReaderEvents(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args)> AamvaCardDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AamvaCardDataReceived += x, x => _data.AamvaCardDataReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args)> BankCardDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BankCardDataReceived += x, x => _data.BankCardDataReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader>(eventHandler => + { + void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader e) => eventHandler(e); + return Handler; + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args)> VendorSpecificDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VendorSpecificDataReceived += x, x => _data.VendorSpecificDataReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxClaimedPosPrinterEvents + { + private readonly global::Windows.Devices.PointOfService.ClaimedPosPrinter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxClaimedPosPrinterEvents(global::Windows.Devices.PointOfService.ClaimedPosPrinter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args)> ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMagneticStripeReaderEvents + { + private readonly global::Windows.Devices.PointOfService.MagneticStripeReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMagneticStripeReaderEvents(global::Windows.Devices.PointOfService.MagneticStripeReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPosPrinterEvents + { + private readonly global::Windows.Devices.PointOfService.PosPrinter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPosPrinterEvents(global::Windows.Devices.PointOfService.PosPrinter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + } +} + +namespace Windows.Devices.PointOfService.Provider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBarcodeScannerFrameReaderEvents Events(this global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader item) => new RxBarcodeScannerFrameReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBarcodeScannerProviderConnectionEvents Events(this global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection item) => new RxBarcodeScannerProviderConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBarcodeScannerFrameReaderEvents + { + private readonly global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBarcodeScannerFrameReaderEvents(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBarcodeScannerProviderConnectionEvents + { + private readonly global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBarcodeScannerProviderConnectionEvents(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args)> DisableScannerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisableScannerRequested += x, x => _data.DisableScannerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args)> EnableScannerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnableScannerRequested += x, x => _data.EnableScannerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args)> GetBarcodeSymbologyAttributesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GetBarcodeSymbologyAttributesRequested += x, x => _data.GetBarcodeSymbologyAttributesRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args)> HideVideoPreviewRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HideVideoPreviewRequested += x, x => _data.HideVideoPreviewRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args)> SetActiveSymbologiesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SetActiveSymbologiesRequested += x, x => _data.SetActiveSymbologiesRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args)> SetBarcodeSymbologyAttributesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SetBarcodeSymbologyAttributesRequested += x, x => _data.SetBarcodeSymbologyAttributesRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args)> StartSoftwareTriggerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StartSoftwareTriggerRequested += x, x => _data.StartSoftwareTriggerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args)> StopSoftwareTriggerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StopSoftwareTriggerRequested += x, x => _data.StopSoftwareTriggerRequested -= x); + } +} + +namespace Windows.Devices.Power +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBatteryEvents Events(this global::Windows.Devices.Power.Battery item) => new RxBatteryEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBatteryEvents + { + private readonly global::Windows.Devices.Power.Battery _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBatteryEvents(global::Windows.Devices.Power.Battery data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Power.Battery sender, object args)> ReportUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Power.Battery sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Power.Battery sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReportUpdated += x, x => _data.ReportUpdated -= x); + } +} + +namespace Windows.Devices.Printers.Extensions +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrint3DWorkflowEvents Events(this global::Windows.Devices.Printers.Extensions.Print3DWorkflow item) => new RxPrint3DWorkflowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintTaskConfigurationEvents Events(this global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration item) => new RxPrintTaskConfigurationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrint3DWorkflowEvents + { + private readonly global::Windows.Devices.Printers.Extensions.Print3DWorkflow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrint3DWorkflowEvents(global::Windows.Devices.Printers.Extensions.Print3DWorkflow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args)> PrinterChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrinterChanged += x, x => _data.PrinterChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args)> PrintRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrintRequested += x, x => _data.PrintRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintTaskConfigurationEvents + { + private readonly global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintTaskConfigurationEvents(global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration sender, global::Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequestedEventArgs args)> SaveRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration sender, global::Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Printers.Extensions.PrintTaskConfiguration sender, global::Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SaveRequested += x, x => _data.SaveRequested -= x); + } +} + +namespace Windows.Devices.Radios +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioEvents Events(this global::Windows.Devices.Radios.Radio item) => new RxRadioEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioEvents + { + private readonly global::Windows.Devices.Radios.Radio _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioEvents(global::Windows.Devices.Radios.Radio data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Radios.Radio sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Radios.Radio sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Radios.Radio sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace Windows.Devices.Sensors +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAccelerometerEvents Events(this global::Windows.Devices.Sensors.Accelerometer item) => new RxAccelerometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxActivitySensorEvents Events(this global::Windows.Devices.Sensors.ActivitySensor item) => new RxActivitySensorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAltimeterEvents Events(this global::Windows.Devices.Sensors.Altimeter item) => new RxAltimeterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBarometerEvents Events(this global::Windows.Devices.Sensors.Barometer item) => new RxBarometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompassEvents Events(this global::Windows.Devices.Sensors.Compass item) => new RxCompassEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGyrometerEvents Events(this global::Windows.Devices.Sensors.Gyrometer item) => new RxGyrometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHingeAngleSensorEvents Events(this global::Windows.Devices.Sensors.HingeAngleSensor item) => new RxHingeAngleSensorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInclinometerEvents Events(this global::Windows.Devices.Sensors.Inclinometer item) => new RxInclinometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLightSensorEvents Events(this global::Windows.Devices.Sensors.LightSensor item) => new RxLightSensorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMagnetometerEvents Events(this global::Windows.Devices.Sensors.Magnetometer item) => new RxMagnetometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxOrientationSensorEvents Events(this global::Windows.Devices.Sensors.OrientationSensor item) => new RxOrientationSensorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPedometerEvents Events(this global::Windows.Devices.Sensors.Pedometer item) => new RxPedometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProximitySensorEvents Events(this global::Windows.Devices.Sensors.ProximitySensor item) => new RxProximitySensorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSimpleOrientationSensorEvents Events(this global::Windows.Devices.Sensors.SimpleOrientationSensor item) => new RxSimpleOrientationSensorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAccelerometerEvents + { + private readonly global::Windows.Devices.Sensors.Accelerometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAccelerometerEvents(global::Windows.Devices.Sensors.Accelerometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args)> Shaken => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Shaken += x, x => _data.Shaken -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxActivitySensorEvents + { + private readonly global::Windows.Devices.Sensors.ActivitySensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxActivitySensorEvents(global::Windows.Devices.Sensors.ActivitySensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAltimeterEvents + { + private readonly global::Windows.Devices.Sensors.Altimeter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAltimeterEvents(global::Windows.Devices.Sensors.Altimeter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBarometerEvents + { + private readonly global::Windows.Devices.Sensors.Barometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBarometerEvents(global::Windows.Devices.Sensors.Barometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompassEvents + { + private readonly global::Windows.Devices.Sensors.Compass _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompassEvents(global::Windows.Devices.Sensors.Compass data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGyrometerEvents + { + private readonly global::Windows.Devices.Sensors.Gyrometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGyrometerEvents(global::Windows.Devices.Sensors.Gyrometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHingeAngleSensorEvents + { + private readonly global::Windows.Devices.Sensors.HingeAngleSensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHingeAngleSensorEvents(global::Windows.Devices.Sensors.HingeAngleSensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInclinometerEvents + { + private readonly global::Windows.Devices.Sensors.Inclinometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInclinometerEvents(global::Windows.Devices.Sensors.Inclinometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLightSensorEvents + { + private readonly global::Windows.Devices.Sensors.LightSensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLightSensorEvents(global::Windows.Devices.Sensors.LightSensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMagnetometerEvents + { + private readonly global::Windows.Devices.Sensors.Magnetometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMagnetometerEvents(global::Windows.Devices.Sensors.Magnetometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxOrientationSensorEvents + { + private readonly global::Windows.Devices.Sensors.OrientationSensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxOrientationSensorEvents(global::Windows.Devices.Sensors.OrientationSensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPedometerEvents + { + private readonly global::Windows.Devices.Sensors.Pedometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPedometerEvents(global::Windows.Devices.Sensors.Pedometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProximitySensorEvents + { + private readonly global::Windows.Devices.Sensors.ProximitySensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProximitySensorEvents(global::Windows.Devices.Sensors.ProximitySensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSimpleOrientationSensorEvents + { + private readonly global::Windows.Devices.Sensors.SimpleOrientationSensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSimpleOrientationSensorEvents(global::Windows.Devices.Sensors.SimpleOrientationSensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args)> OrientationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + } +} + +namespace Windows.Devices.Sensors.Custom +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCustomSensorEvents Events(this global::Windows.Devices.Sensors.Custom.CustomSensor item) => new RxCustomSensorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCustomSensorEvents + { + private readonly global::Windows.Devices.Sensors.Custom.CustomSensor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCustomSensorEvents(global::Windows.Devices.Sensors.Custom.CustomSensor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + } +} + +namespace Windows.Devices.SerialCommunication +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSerialDeviceEvents Events(this global::Windows.Devices.SerialCommunication.SerialDevice item) => new RxSerialDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSerialDeviceEvents + { + private readonly global::Windows.Devices.SerialCommunication.SerialDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSerialDeviceEvents(global::Windows.Devices.SerialCommunication.SerialDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args)> ErrorReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorReceived += x, x => _data.ErrorReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args)> PinChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PinChanged += x, x => _data.PinChanged -= x); + } +} + +namespace Windows.Devices.SmartCards +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSmartCardEmulatorEvents Events(this global::Windows.Devices.SmartCards.SmartCardEmulator item) => new RxSmartCardEmulatorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSmartCardReaderEvents Events(this global::Windows.Devices.SmartCards.SmartCardReader item) => new RxSmartCardReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSmartCardEmulatorEvents + { + private readonly global::Windows.Devices.SmartCards.SmartCardEmulator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSmartCardEmulatorEvents(global::Windows.Devices.SmartCards.SmartCardEmulator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorApduReceivedEventArgs args)> ApduReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorApduReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorApduReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ApduReceived += x, x => _data.ApduReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorConnectionDeactivatedEventArgs args)> ConnectionDeactivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorConnectionDeactivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SmartCards.SmartCardEmulator sender, global::Windows.Devices.SmartCards.SmartCardEmulatorConnectionDeactivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionDeactivated += x, x => _data.ConnectionDeactivated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSmartCardReaderEvents + { + private readonly global::Windows.Devices.SmartCards.SmartCardReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSmartCardReaderEvents(global::Windows.Devices.SmartCards.SmartCardReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args)> CardAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CardAdded += x, x => _data.CardAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args)> CardRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CardRemoved += x, x => _data.CardRemoved -= x); + } +} + +namespace Windows.Devices.Sms +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxISmsDeviceEvents Events(this global::Windows.Devices.Sms.ISmsDevice item) => new RxISmsDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSmsDeviceEvents Events(this global::Windows.Devices.Sms.SmsDevice item) => new RxSmsDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSmsDevice2Events Events(this global::Windows.Devices.Sms.SmsDevice2 item) => new RxSmsDevice2Events(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSmsMessageRegistrationEvents Events(this global::Windows.Devices.Sms.SmsMessageRegistration item) => new RxSmsMessageRegistrationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxISmsDeviceEvents + { + private readonly global::Windows.Devices.Sms.ISmsDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxISmsDeviceEvents(global::Windows.Devices.Sms.ISmsDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SmsDeviceStatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsDevice sender) => eventHandler(sender); + return Handler; + }, x => _data.SmsDeviceStatusChanged += x, x => _data.SmsDeviceStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sms.SmsDevice sender, global::Windows.Devices.Sms.SmsMessageReceivedEventArgs e)> SmsMessageReceived => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsDevice sender, global::Windows.Devices.Sms.SmsMessageReceivedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.SmsMessageReceived += x, x => _data.SmsMessageReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSmsDeviceEvents + { + private readonly global::Windows.Devices.Sms.SmsDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSmsDeviceEvents(global::Windows.Devices.Sms.SmsDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SmsDeviceStatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsDevice sender) => eventHandler(sender); + return Handler; + }, x => _data.SmsDeviceStatusChanged += x, x => _data.SmsDeviceStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sms.SmsDevice sender, global::Windows.Devices.Sms.SmsMessageReceivedEventArgs e)> SmsMessageReceived => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsDevice sender, global::Windows.Devices.Sms.SmsMessageReceivedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.SmsMessageReceived += x, x => _data.SmsMessageReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSmsDevice2Events + { + private readonly global::Windows.Devices.Sms.SmsDevice2 _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSmsDevice2Events(global::Windows.Devices.Sms.SmsDevice2 data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sms.SmsDevice2 sender, object args)> DeviceStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sms.SmsDevice2 sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsDevice2 sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DeviceStatusChanged += x, x => _data.DeviceStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSmsMessageRegistrationEvents + { + private readonly global::Windows.Devices.Sms.SmsMessageRegistration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSmsMessageRegistrationEvents(global::Windows.Devices.Sms.SmsMessageRegistration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args)>(eventHandler => + { + void Handler(global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } +} + +namespace Windows.Devices.Usb +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUsbInterruptInPipeEvents Events(this global::Windows.Devices.Usb.UsbInterruptInPipe item) => new RxUsbInterruptInPipeEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUsbInterruptInPipeEvents + { + private readonly global::Windows.Devices.Usb.UsbInterruptInPipe _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUsbInterruptInPipeEvents(global::Windows.Devices.Usb.UsbInterruptInPipe data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args)> DataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); + } +} + +namespace Windows.Devices.WiFi +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiAdapterEvents Events(this global::Windows.Devices.WiFi.WiFiAdapter item) => new RxWiFiAdapterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiAdapterEvents + { + private readonly global::Windows.Devices.WiFi.WiFiAdapter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiAdapterEvents(global::Windows.Devices.WiFi.WiFiAdapter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFi.WiFiAdapter sender, object args)> AvailableNetworksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFi.WiFiAdapter sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFi.WiFiAdapter sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailableNetworksChanged += x, x => _data.AvailableNetworksChanged -= x); + } +} + +namespace Windows.Devices.WiFiDirect +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectAdvertisementPublisherEvents Events(this global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher item) => new RxWiFiDirectAdvertisementPublisherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectConnectionListenerEvents Events(this global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener item) => new RxWiFiDirectConnectionListenerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectDeviceEvents Events(this global::Windows.Devices.WiFiDirect.WiFiDirectDevice item) => new RxWiFiDirectDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectAdvertisementPublisherEvents + { + private readonly global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectAdvertisementPublisherEvents(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectConnectionListenerEvents + { + private readonly global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectConnectionListenerEvents(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args)> ConnectionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectDeviceEvents + { + private readonly global::Windows.Devices.WiFiDirect.WiFiDirectDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectDeviceEvents(global::Windows.Devices.WiFiDirect.WiFiDirectDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args)> ConnectionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + } +} + +namespace Windows.Devices.WiFiDirect.Services +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectServiceEvents Events(this global::Windows.Devices.WiFiDirect.Services.WiFiDirectService item) => new RxWiFiDirectServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectServiceAdvertiserEvents Events(this global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser item) => new RxWiFiDirectServiceAdvertiserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWiFiDirectServiceSessionEvents Events(this global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession item) => new RxWiFiDirectServiceSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectServiceEvents + { + private readonly global::Windows.Devices.WiFiDirect.Services.WiFiDirectService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectServiceEvents(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args)> SessionDeferred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionDeferred += x, x => _data.SessionDeferred -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectServiceAdvertiserEvents + { + private readonly global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectServiceAdvertiserEvents(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args)> AdvertisementStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args)> AutoAcceptSessionConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutoAcceptSessionConnected += x, x => _data.AutoAcceptSessionConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args)> SessionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionRequested += x, x => _data.SessionRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWiFiDirectServiceSessionEvents + { + private readonly global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWiFiDirectServiceSessionEvents(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args)> RemotePortAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RemotePortAdded += x, x => _data.RemotePortAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args)> SessionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + } +} + +namespace Windows.Foundation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIMemoryBufferReferenceEvents Events(this global::Windows.Foundation.IMemoryBufferReference item) => new RxIMemoryBufferReferenceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIMemoryBufferReferenceEvents + { + private readonly global::Windows.Foundation.IMemoryBufferReference _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIMemoryBufferReferenceEvents(global::Windows.Foundation.IMemoryBufferReference data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.IMemoryBufferReference sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.IMemoryBufferReference sender, object args)>(eventHandler => + { + void Handler(global::Windows.Foundation.IMemoryBufferReference sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + } +} + +namespace Windows.Foundation.Collections +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPropertySetEvents Events(this global::Windows.Foundation.Collections.PropertySet item) => new RxPropertySetEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStringMapEvents Events(this global::Windows.Foundation.Collections.StringMap item) => new RxStringMapEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxValueSetEvents Events(this global::Windows.Foundation.Collections.ValueSet item) => new RxValueSetEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPropertySetEvents + { + private readonly global::Windows.Foundation.Collections.PropertySet _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPropertySetEvents(global::Windows.Foundation.Collections.PropertySet data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStringMapEvents + { + private readonly global::Windows.Foundation.Collections.StringMap _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStringMapEvents(global::Windows.Foundation.Collections.StringMap data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxValueSetEvents + { + private readonly global::Windows.Foundation.Collections.ValueSet _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxValueSetEvents(global::Windows.Foundation.Collections.ValueSet data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } +} + +namespace Windows.Foundation.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileLoggingSessionEvents Events(this global::Windows.Foundation.Diagnostics.FileLoggingSession item) => new RxFileLoggingSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIFileLoggingSessionEvents Events(this global::Windows.Foundation.Diagnostics.IFileLoggingSession item) => new RxIFileLoggingSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxILoggingChannelEvents Events(this global::Windows.Foundation.Diagnostics.ILoggingChannel item) => new RxILoggingChannelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLoggingChannelEvents Events(this global::Windows.Foundation.Diagnostics.LoggingChannel item) => new RxLoggingChannelEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileLoggingSessionEvents + { + private readonly global::Windows.Foundation.Diagnostics.FileLoggingSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileLoggingSessionEvents(global::Windows.Foundation.Diagnostics.FileLoggingSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)> LogFileGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIFileLoggingSessionEvents + { + private readonly global::Windows.Foundation.Diagnostics.IFileLoggingSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIFileLoggingSessionEvents(global::Windows.Foundation.Diagnostics.IFileLoggingSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)> LogFileGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxILoggingChannelEvents + { + private readonly global::Windows.Foundation.Diagnostics.ILoggingChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxILoggingChannelEvents(global::Windows.Foundation.Diagnostics.ILoggingChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)> LoggingEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)>(eventHandler => + { + void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLoggingChannelEvents + { + private readonly global::Windows.Foundation.Diagnostics.LoggingChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLoggingChannelEvents(global::Windows.Foundation.Diagnostics.LoggingChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)> LoggingEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)>(eventHandler => + { + void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + } +} + +namespace Windows.Gaming.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxArcadeStickEvents Events(this global::Windows.Gaming.Input.ArcadeStick item) => new RxArcadeStickEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFlightStickEvents Events(this global::Windows.Gaming.Input.FlightStick item) => new RxFlightStickEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGamepadEvents Events(this global::Windows.Gaming.Input.Gamepad item) => new RxGamepadEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIGameControllerEvents Events(this global::Windows.Gaming.Input.IGameController item) => new RxIGameControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRacingWheelEvents Events(this global::Windows.Gaming.Input.RacingWheel item) => new RxRacingWheelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRawGameControllerEvents Events(this global::Windows.Gaming.Input.RawGameController item) => new RxRawGameControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUINavigationControllerEvents Events(this global::Windows.Gaming.Input.UINavigationController item) => new RxUINavigationControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxArcadeStickEvents + { + private readonly global::Windows.Gaming.Input.ArcadeStick _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxArcadeStickEvents(global::Windows.Gaming.Input.ArcadeStick data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFlightStickEvents + { + private readonly global::Windows.Gaming.Input.FlightStick _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFlightStickEvents(global::Windows.Gaming.Input.FlightStick data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGamepadEvents + { + private readonly global::Windows.Gaming.Input.Gamepad _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGamepadEvents(global::Windows.Gaming.Input.Gamepad data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIGameControllerEvents + { + private readonly global::Windows.Gaming.Input.IGameController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIGameControllerEvents(global::Windows.Gaming.Input.IGameController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRacingWheelEvents + { + private readonly global::Windows.Gaming.Input.RacingWheel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRacingWheelEvents(global::Windows.Gaming.Input.RacingWheel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRawGameControllerEvents + { + private readonly global::Windows.Gaming.Input.RawGameController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRawGameControllerEvents(global::Windows.Gaming.Input.RawGameController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUINavigationControllerEvents + { + private readonly global::Windows.Gaming.Input.UINavigationController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUINavigationControllerEvents(global::Windows.Gaming.Input.UINavigationController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); + } +} + +namespace Windows.Gaming.UI +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGameChatOverlayMessageSourceEvents Events(this global::Windows.Gaming.UI.GameChatOverlayMessageSource item) => new RxGameChatOverlayMessageSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGameChatOverlayMessageSourceEvents + { + private readonly global::Windows.Gaming.UI.GameChatOverlayMessageSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGameChatOverlayMessageSourceEvents(global::Windows.Gaming.UI.GameChatOverlayMessageSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Gaming.UI.GameChatOverlayMessageSource sender, global::Windows.Gaming.UI.GameChatMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.UI.GameChatOverlayMessageSource sender, global::Windows.Gaming.UI.GameChatMessageReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Gaming.UI.GameChatOverlayMessageSource sender, global::Windows.Gaming.UI.GameChatMessageReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } +} + +namespace Windows.Graphics.Capture +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDirect3D11CaptureFramePoolEvents Events(this global::Windows.Graphics.Capture.Direct3D11CaptureFramePool item) => new RxDirect3D11CaptureFramePoolEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGraphicsCaptureItemEvents Events(this global::Windows.Graphics.Capture.GraphicsCaptureItem item) => new RxGraphicsCaptureItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDirect3D11CaptureFramePoolEvents + { + private readonly global::Windows.Graphics.Capture.Direct3D11CaptureFramePool _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDirect3D11CaptureFramePoolEvents(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGraphicsCaptureItemEvents + { + private readonly global::Windows.Graphics.Capture.GraphicsCaptureItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGraphicsCaptureItemEvents(global::Windows.Graphics.Capture.GraphicsCaptureItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + } +} + +namespace Windows.Graphics.Display +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBrightnessOverrideEvents Events(this global::Windows.Graphics.Display.BrightnessOverride item) => new RxBrightnessOverrideEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDisplayEnhancementOverrideEvents Events(this global::Windows.Graphics.Display.DisplayEnhancementOverride item) => new RxDisplayEnhancementOverrideEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDisplayInformationEvents Events(this global::Windows.Graphics.Display.DisplayInformation item) => new RxDisplayInformationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBrightnessOverrideEvents + { + private readonly global::Windows.Graphics.Display.BrightnessOverride _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBrightnessOverrideEvents(global::Windows.Graphics.Display.BrightnessOverride data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.BrightnessOverride sender, object args)> BrightnessLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.BrightnessOverride sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BrightnessLevelChanged += x, x => _data.BrightnessLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.BrightnessOverride sender, object args)> IsOverrideActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.BrightnessOverride sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.BrightnessOverride sender, object args)> IsSupportedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.BrightnessOverride sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDisplayEnhancementOverrideEvents + { + private readonly global::Windows.Graphics.Display.DisplayEnhancementOverride _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDisplayEnhancementOverrideEvents(global::Windows.Graphics.Display.DisplayEnhancementOverride data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)> CanOverrideChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CanOverrideChanged += x, x => _data.CanOverrideChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args)> DisplayEnhancementOverrideCapabilitiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisplayEnhancementOverrideCapabilitiesChanged += x, x => _data.DisplayEnhancementOverrideCapabilitiesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)> IsOverrideActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDisplayInformationEvents + { + private readonly global::Windows.Graphics.Display.DisplayInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDisplayInformationEvents(global::Windows.Graphics.Display.DisplayInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> AdvancedColorInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AdvancedColorInfoChanged += x, x => _data.AdvancedColorInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> ColorProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ColorProfileChanged += x, x => _data.ColorProfileChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> DpiChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> OrientationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> StereoEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StereoEnabledChanged += x, x => _data.StereoEnabledChanged -= x); + } +} + +namespace Windows.Graphics.Display.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHdmiDisplayInformationEvents Events(this global::Windows.Graphics.Display.Core.HdmiDisplayInformation item) => new RxHdmiDisplayInformationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHdmiDisplayInformationEvents + { + private readonly global::Windows.Graphics.Display.Core.HdmiDisplayInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHdmiDisplayInformationEvents(global::Windows.Graphics.Display.Core.HdmiDisplayInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args)> DisplayModesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisplayModesChanged += x, x => _data.DisplayModesChanged -= x); + } +} + +namespace Windows.Graphics.Holographic +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHolographicSpaceEvents Events(this global::Windows.Graphics.Holographic.HolographicSpace item) => new RxHolographicSpaceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHolographicSpaceEvents + { + private readonly global::Windows.Graphics.Holographic.HolographicSpace _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHolographicSpaceEvents(global::Windows.Graphics.Holographic.HolographicSpace data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args)> CameraAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraAdded += x, x => _data.CameraAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args)> CameraRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraRemoved += x, x => _data.CameraRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Holographic.HolographicSpace sender, object args)> UserPresenceChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Holographic.HolographicSpace sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserPresenceChanged += x, x => _data.UserPresenceChanged -= x); + } +} + +namespace Windows.Graphics.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintManagerEvents Events(this global::Windows.Graphics.Printing.PrintManager item) => new RxPrintManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintTaskEvents Events(this global::Windows.Graphics.Printing.PrintTask item) => new RxPrintTaskEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintManagerEvents + { + private readonly global::Windows.Graphics.Printing.PrintManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintManagerEvents(global::Windows.Graphics.Printing.PrintManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args)> PrintTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrintTaskRequested += x, x => _data.PrintTaskRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintTaskEvents + { + private readonly global::Windows.Graphics.Printing.PrintTask _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintTaskEvents(global::Windows.Graphics.Printing.PrintTask data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, object args)> Previewing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Previewing += x, x => _data.Previewing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args)> Progressing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Progressing += x, x => _data.Progressing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, object args)> Submitting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Submitting += x, x => _data.Submitting -= x); + } +} + +namespace Windows.Graphics.Printing.OptionDetails +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintTaskOptionDetailsEvents Events(this global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails item) => new RxPrintTaskOptionDetailsEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintTaskOptionDetailsEvents + { + private readonly global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintTaskOptionDetailsEvents(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args)> BeginValidation => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BeginValidation += x, x => _data.BeginValidation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args)> OptionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionChanged += x, x => _data.OptionChanged -= x); + } +} + +namespace Windows.Graphics.Printing.Workflow +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintWorkflowBackgroundSessionEvents Events(this global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession item) => new RxPrintWorkflowBackgroundSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintWorkflowForegroundSessionEvents Events(this global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession item) => new RxPrintWorkflowForegroundSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintWorkflowBackgroundSessionEvents + { + private readonly global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintWorkflowBackgroundSessionEvents(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args)> SetupRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args)> Submitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Submitted += x, x => _data.Submitted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintWorkflowForegroundSessionEvents + { + private readonly global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintWorkflowForegroundSessionEvents(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args)> SetupRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args)> XpsDataAvailable => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.XpsDataAvailable += x, x => _data.XpsDataAvailable -= x); + } +} + +namespace Windows.Graphics.Printing3D +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrint3DManagerEvents Events(this global::Windows.Graphics.Printing3D.Print3DManager item) => new RxPrint3DManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrint3DTaskEvents Events(this global::Windows.Graphics.Printing3D.Print3DTask item) => new RxPrint3DTaskEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrint3DManagerEvents + { + private readonly global::Windows.Graphics.Printing3D.Print3DManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrint3DManagerEvents(global::Windows.Graphics.Printing3D.Print3DManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing3D.Print3DManager sender, global::Windows.Graphics.Printing3D.Print3DTaskRequestedEventArgs args)> TaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing3D.Print3DManager sender, global::Windows.Graphics.Printing3D.Print3DTaskRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing3D.Print3DManager sender, global::Windows.Graphics.Printing3D.Print3DTaskRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TaskRequested += x, x => _data.TaskRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrint3DTaskEvents + { + private readonly global::Windows.Graphics.Printing3D.Print3DTask _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrint3DTaskEvents(global::Windows.Graphics.Printing3D.Print3DTask data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskSourceChangedEventArgs args)> SourceChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskSourceChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing3D.Print3DTask sender, global::Windows.Graphics.Printing3D.Print3DTaskSourceChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceChanged += x, x => _data.SourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Graphics.Printing3D.Print3DTask sender, object args)> Submitting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing3D.Print3DTask sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Printing3D.Print3DTask sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Submitting += x, x => _data.Submitting -= x); + } +} + +namespace Windows.Management.Policies +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNamedPolicyDataEvents Events(this global::Windows.Management.Policies.NamedPolicyData item) => new RxNamedPolicyDataEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNamedPolicyDataEvents + { + private readonly global::Windows.Management.Policies.NamedPolicyData _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNamedPolicyDataEvents(global::Windows.Management.Policies.NamedPolicyData data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Management.Policies.NamedPolicyData sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Management.Policies.NamedPolicyData sender, object args)>(eventHandler => + { + void Handler(global::Windows.Management.Policies.NamedPolicyData sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace Windows.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaTimelineControllerEvents Events(this global::Windows.Media.MediaTimelineController item) => new RxMediaTimelineControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSystemMediaTransportControlsEvents Events(this global::Windows.Media.SystemMediaTransportControls item) => new RxSystemMediaTransportControlsEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaTimelineControllerEvents + { + private readonly global::Windows.Media.MediaTimelineController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaTimelineControllerEvents(global::Windows.Media.MediaTimelineController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, object args)> Ended => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Ended += x, x => _data.Ended -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args)> Failed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, object args)> PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSystemMediaTransportControlsEvents + { + private readonly global::Windows.Media.SystemMediaTransportControls _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSystemMediaTransportControlsEvents(global::Windows.Media.SystemMediaTransportControls data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args)> AutoRepeatModeChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutoRepeatModeChangeRequested += x, x => _data.AutoRepeatModeChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args)> ButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args)> PlaybackPositionChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackPositionChangeRequested += x, x => _data.PlaybackPositionChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args)> PlaybackRateChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args)> PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args)> ShuffleEnabledChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShuffleEnabledChangeRequested += x, x => _data.ShuffleEnabledChangeRequested -= x); + } +} + +namespace Windows.Media.AppBroadcasting +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastingMonitorEvents Events(this global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor item) => new RxAppBroadcastingMonitorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastingMonitorEvents + { + private readonly global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastingMonitorEvents(global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor sender, object args)> IsCurrentAppBroadcastingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.AppBroadcasting.AppBroadcastingMonitor sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsCurrentAppBroadcastingChanged += x, x => _data.IsCurrentAppBroadcastingChanged -= x); + } +} + +namespace Windows.Media.Audio +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioFileInputNodeEvents Events(this global::Windows.Media.Audio.AudioFileInputNode item) => new RxAudioFileInputNodeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioFrameInputNodeEvents Events(this global::Windows.Media.Audio.AudioFrameInputNode item) => new RxAudioFrameInputNodeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioGraphEvents Events(this global::Windows.Media.Audio.AudioGraph item) => new RxAudioGraphEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioPlaybackConnectionEvents Events(this global::Windows.Media.Audio.AudioPlaybackConnection item) => new RxAudioPlaybackConnectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioStateMonitorEvents Events(this global::Windows.Media.Audio.AudioStateMonitor item) => new RxAudioStateMonitorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaSourceAudioInputNodeEvents Events(this global::Windows.Media.Audio.MediaSourceAudioInputNode item) => new RxMediaSourceAudioInputNodeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialAudioDeviceConfigurationEvents Events(this global::Windows.Media.Audio.SpatialAudioDeviceConfiguration item) => new RxSpatialAudioDeviceConfigurationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioFileInputNodeEvents + { + private readonly global::Windows.Media.Audio.AudioFileInputNode _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioFileInputNodeEvents(global::Windows.Media.Audio.AudioFileInputNode data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioFileInputNode sender, object args)> FileCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioFileInputNode sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioFileInputNode sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FileCompleted += x, x => _data.FileCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioFrameInputNodeEvents + { + private readonly global::Windows.Media.Audio.AudioFrameInputNode _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioFrameInputNodeEvents(global::Windows.Media.Audio.AudioFrameInputNode data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args)> AudioFrameCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioFrameCompleted += x, x => _data.AudioFrameCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args)> QuantumStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioGraphEvents + { + private readonly global::Windows.Media.Audio.AudioGraph _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioGraphEvents(global::Windows.Media.Audio.AudioGraph data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioGraph sender, object args)> QuantumProcessed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioGraph sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuantumProcessed += x, x => _data.QuantumProcessed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioGraph sender, object args)> QuantumStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioGraph sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args)> UnrecoverableErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnrecoverableErrorOccurred += x, x => _data.UnrecoverableErrorOccurred -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioPlaybackConnectionEvents + { + private readonly global::Windows.Media.Audio.AudioPlaybackConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioPlaybackConnectionEvents(global::Windows.Media.Audio.AudioPlaybackConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioPlaybackConnection sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioPlaybackConnection sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioPlaybackConnection sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioStateMonitorEvents + { + private readonly global::Windows.Media.Audio.AudioStateMonitor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioStateMonitorEvents(global::Windows.Media.Audio.AudioStateMonitor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.AudioStateMonitor sender, object args)> SoundLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioStateMonitor sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.AudioStateMonitor sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SoundLevelChanged += x, x => _data.SoundLevelChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaSourceAudioInputNodeEvents + { + private readonly global::Windows.Media.Audio.MediaSourceAudioInputNode _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaSourceAudioInputNodeEvents(global::Windows.Media.Audio.MediaSourceAudioInputNode data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args)> MediaSourceCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaSourceCompleted += x, x => _data.MediaSourceCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialAudioDeviceConfigurationEvents + { + private readonly global::Windows.Media.Audio.SpatialAudioDeviceConfiguration _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialAudioDeviceConfigurationEvents(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args)> ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + } +} + +namespace Windows.Media.Capture +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAdvancedPhotoCaptureEvents Events(this global::Windows.Media.Capture.AdvancedPhotoCapture item) => new RxAdvancedPhotoCaptureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastBackgroundServiceEvents Events(this global::Windows.Media.Capture.AppBroadcastBackgroundService item) => new RxAppBroadcastBackgroundServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastBackgroundServiceSignInInfoEvents Events(this global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo item) => new RxAppBroadcastBackgroundServiceSignInInfoEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastBackgroundServiceStreamInfoEvents Events(this global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo item) => new RxAppBroadcastBackgroundServiceStreamInfoEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastPreviewEvents Events(this global::Windows.Media.Capture.AppBroadcastPreview item) => new RxAppBroadcastPreviewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastPreviewStreamReaderEvents Events(this global::Windows.Media.Capture.AppBroadcastPreviewStreamReader item) => new RxAppBroadcastPreviewStreamReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastStateEvents Events(this global::Windows.Media.Capture.AppBroadcastState item) => new RxAppBroadcastStateEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBroadcastStreamReaderEvents Events(this global::Windows.Media.Capture.AppBroadcastStreamReader item) => new RxAppBroadcastStreamReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppCaptureEvents Events(this global::Windows.Media.Capture.AppCapture item) => new RxAppCaptureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppCaptureMetadataWriterEvents Events(this global::Windows.Media.Capture.AppCaptureMetadataWriter item) => new RxAppCaptureMetadataWriterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppCaptureRecordOperationEvents Events(this global::Windows.Media.Capture.AppCaptureRecordOperation item) => new RxAppCaptureRecordOperationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppCaptureStateEvents Events(this global::Windows.Media.Capture.AppCaptureState item) => new RxAppCaptureStateEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGameBarServicesEvents Events(this global::Windows.Media.Capture.GameBarServices item) => new RxGameBarServicesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGameBarServicesManagerEvents Events(this global::Windows.Media.Capture.GameBarServicesManager item) => new RxGameBarServicesManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLowLagPhotoSequenceCaptureEvents Events(this global::Windows.Media.Capture.LowLagPhotoSequenceCapture item) => new RxLowLagPhotoSequenceCaptureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaCaptureEvents Events(this global::Windows.Media.Capture.MediaCapture item) => new RxMediaCaptureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaCaptureRelativePanelWatcherEvents Events(this global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher item) => new RxMediaCaptureRelativePanelWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScreenCaptureEvents Events(this global::Windows.Media.Capture.ScreenCapture item) => new RxScreenCaptureEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAdvancedPhotoCaptureEvents + { + private readonly global::Windows.Media.Capture.AdvancedPhotoCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAdvancedPhotoCaptureEvents(global::Windows.Media.Capture.AdvancedPhotoCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args)> AllPhotosCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AllPhotosCaptured += x, x => _data.AllPhotosCaptured -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args)> OptionalReferencePhotoCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionalReferencePhotoCaptured += x, x => _data.OptionalReferencePhotoCaptured -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastBackgroundServiceEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastBackgroundService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastBackgroundServiceEvents(global::Windows.Media.Capture.AppBroadcastBackgroundService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)> BroadcastChannelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BroadcastChannelChanged += x, x => _data.BroadcastChannelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)> BroadcastLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BroadcastLanguageChanged += x, x => _data.BroadcastLanguageChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)> BroadcastTitleChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BroadcastTitleChanged += x, x => _data.BroadcastTitleChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, global::Windows.Media.Capture.AppBroadcastHeartbeatRequestedEventArgs args)> HeartbeatRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundService sender, global::Windows.Media.Capture.AppBroadcastHeartbeatRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundService sender, global::Windows.Media.Capture.AppBroadcastHeartbeatRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeartbeatRequested += x, x => _data.HeartbeatRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastBackgroundServiceSignInInfoEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastBackgroundServiceSignInInfoEvents(global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, global::Windows.Media.Capture.AppBroadcastSignInStateChangedEventArgs args)> SignInStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, global::Windows.Media.Capture.AppBroadcastSignInStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, global::Windows.Media.Capture.AppBroadcastSignInStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SignInStateChanged += x, x => _data.SignInStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, object args)> UserNameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserNameChanged += x, x => _data.UserNameChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastBackgroundServiceStreamInfoEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastBackgroundServiceStreamInfoEvents(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args)> StreamStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StreamStateChanged += x, x => _data.StreamStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args)> VideoEncodingBitrateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoEncodingBitrateChanged += x, x => _data.VideoEncodingBitrateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args)> VideoEncodingResolutionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoEncodingResolutionChanged += x, x => _data.VideoEncodingResolutionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastPreviewEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastPreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastPreviewEvents(global::Windows.Media.Capture.AppBroadcastPreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastPreview sender, global::Windows.Media.Capture.AppBroadcastPreviewStateChangedEventArgs args)> PreviewStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastPreview sender, global::Windows.Media.Capture.AppBroadcastPreviewStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastPreview sender, global::Windows.Media.Capture.AppBroadcastPreviewStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PreviewStateChanged += x, x => _data.PreviewStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastPreviewStreamReaderEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastPreviewStreamReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastPreviewStreamReaderEvents(global::Windows.Media.Capture.AppBroadcastPreviewStreamReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastPreviewStreamReader sender, object args)> VideoFrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastPreviewStreamReader sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastPreviewStreamReader sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoFrameArrived += x, x => _data.VideoFrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastStateEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastState _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastStateEvents(global::Windows.Media.Capture.AppBroadcastState data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastCameraCaptureStateChangedEventArgs args)> CameraCaptureStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastCameraCaptureStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastCameraCaptureStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraCaptureStateChanged += x, x => _data.CameraCaptureStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, object args)> CaptureTargetClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CaptureTargetClosed += x, x => _data.CaptureTargetClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastMicrophoneCaptureStateChangedEventArgs args)> MicrophoneCaptureStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastMicrophoneCaptureStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastMicrophoneCaptureStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MicrophoneCaptureStateChanged += x, x => _data.MicrophoneCaptureStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastPlugInStateChangedEventArgs args)> PlugInStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastPlugInStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastPlugInStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlugInStateChanged += x, x => _data.PlugInStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args)> StreamStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StreamStateChanged += x, x => _data.StreamStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastViewerCountChangedEventArgs args)> ViewerCountChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastViewerCountChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastState sender, global::Windows.Media.Capture.AppBroadcastViewerCountChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ViewerCountChanged += x, x => _data.ViewerCountChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBroadcastStreamReaderEvents + { + private readonly global::Windows.Media.Capture.AppBroadcastStreamReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBroadcastStreamReaderEvents(global::Windows.Media.Capture.AppBroadcastStreamReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args)> AudioFrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioFrameArrived += x, x => _data.AudioFrameArrived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args)> VideoFrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppBroadcastStreamReader sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoFrameArrived += x, x => _data.VideoFrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppCaptureEvents + { + private readonly global::Windows.Media.Capture.AppCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppCaptureEvents(global::Windows.Media.Capture.AppCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCapture sender, object args)> CapturingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCapture sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCapture sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CapturingChanged += x, x => _data.CapturingChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppCaptureMetadataWriterEvents + { + private readonly global::Windows.Media.Capture.AppCaptureMetadataWriter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppCaptureMetadataWriterEvents(global::Windows.Media.Capture.AppCaptureMetadataWriter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureMetadataWriter sender, object args)> MetadataPurged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureMetadataWriter sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureMetadataWriter sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MetadataPurged += x, x => _data.MetadataPurged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppCaptureRecordOperationEvents + { + private readonly global::Windows.Media.Capture.AppCaptureRecordOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppCaptureRecordOperationEvents(global::Windows.Media.Capture.AppCaptureRecordOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureDurationGeneratedEventArgs args)> DurationGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureDurationGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureDurationGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DurationGenerated += x, x => _data.DurationGenerated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureFileGeneratedEventArgs args)> FileGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureFileGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureFileGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FileGenerated += x, x => _data.FileGenerated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureRecordingStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureRecordingStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureRecordOperation sender, global::Windows.Media.Capture.AppCaptureRecordingStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppCaptureStateEvents + { + private readonly global::Windows.Media.Capture.AppCaptureState _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppCaptureStateEvents(global::Windows.Media.Capture.AppCaptureState data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureState sender, object args)> CaptureTargetClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureState sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureState sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CaptureTargetClosed += x, x => _data.CaptureTargetClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.AppCaptureState sender, global::Windows.Media.Capture.AppCaptureMicrophoneCaptureStateChangedEventArgs args)> MicrophoneCaptureStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCaptureState sender, global::Windows.Media.Capture.AppCaptureMicrophoneCaptureStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.AppCaptureState sender, global::Windows.Media.Capture.AppCaptureMicrophoneCaptureStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MicrophoneCaptureStateChanged += x, x => _data.MicrophoneCaptureStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGameBarServicesEvents + { + private readonly global::Windows.Media.Capture.GameBarServices _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGameBarServicesEvents(global::Windows.Media.Capture.GameBarServices data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.GameBarServices sender, global::Windows.Media.Capture.GameBarServicesCommandEventArgs args)> CommandReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.GameBarServices sender, global::Windows.Media.Capture.GameBarServicesCommandEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.GameBarServices sender, global::Windows.Media.Capture.GameBarServicesCommandEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CommandReceived += x, x => _data.CommandReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGameBarServicesManagerEvents + { + private readonly global::Windows.Media.Capture.GameBarServicesManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGameBarServicesManagerEvents(global::Windows.Media.Capture.GameBarServicesManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.GameBarServicesManager sender, global::Windows.Media.Capture.GameBarServicesManagerGameBarServicesCreatedEventArgs args)> GameBarServicesCreated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.GameBarServicesManager sender, global::Windows.Media.Capture.GameBarServicesManagerGameBarServicesCreatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.GameBarServicesManager sender, global::Windows.Media.Capture.GameBarServicesManagerGameBarServicesCreatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GameBarServicesCreated += x, x => _data.GameBarServicesCreated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLowLagPhotoSequenceCaptureEvents + { + private readonly global::Windows.Media.Capture.LowLagPhotoSequenceCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLowLagPhotoSequenceCaptureEvents(global::Windows.Media.Capture.LowLagPhotoSequenceCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args)> PhotoCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaCaptureEvents + { + private readonly global::Windows.Media.Capture.MediaCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaCaptureEvents(global::Windows.Media.Capture.MediaCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, object args)> CameraStreamStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CameraStreamStateChanged += x, x => _data.CameraStreamStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args)> CaptureDeviceExclusiveControlStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CaptureDeviceExclusiveControlStatusChanged += x, x => _data.CaptureDeviceExclusiveControlStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFailedEventArgs errorEventArgs)> Failed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFailedEventArgs errorEventArgs) => eventHandler((sender, errorEventArgs)); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args)> FocusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FocusChanged += x, x => _data.FocusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args)> PhotoConfirmationCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PhotoConfirmationCaptured += x, x => _data.PhotoConfirmationCaptured -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RecordLimitationExceeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender) => eventHandler(sender); + return Handler; + }, x => _data.RecordLimitationExceeded += x, x => _data.RecordLimitationExceeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, object args)> ThermalStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ThermalStatusChanged += x, x => _data.ThermalStatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaCaptureRelativePanelWatcherEvents + { + private readonly global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaCaptureRelativePanelWatcherEvents(global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.MediaCaptureRelativePanelWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScreenCaptureEvents + { + private readonly global::Windows.Media.Capture.ScreenCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScreenCaptureEvents(global::Windows.Media.Capture.ScreenCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args)> SourceSuspensionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceSuspensionChanged += x, x => _data.SourceSuspensionChanged -= x); + } +} + +namespace Windows.Media.Capture.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVariablePhotoSequenceCaptureEvents Events(this global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture item) => new RxVariablePhotoSequenceCaptureEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVariablePhotoSequenceCaptureEvents + { + private readonly global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVariablePhotoSequenceCaptureEvents(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args)> PhotoCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } +} + +namespace Windows.Media.Capture.Frames +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaFrameReaderEvents Events(this global::Windows.Media.Capture.Frames.MediaFrameReader item) => new RxMediaFrameReaderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaFrameSourceEvents Events(this global::Windows.Media.Capture.Frames.MediaFrameSource item) => new RxMediaFrameSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMultiSourceMediaFrameReaderEvents Events(this global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader item) => new RxMultiSourceMediaFrameReaderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaFrameReaderEvents + { + private readonly global::Windows.Media.Capture.Frames.MediaFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaFrameReaderEvents(global::Windows.Media.Capture.Frames.MediaFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaFrameSourceEvents + { + private readonly global::Windows.Media.Capture.Frames.MediaFrameSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaFrameSourceEvents(global::Windows.Media.Capture.Frames.MediaFrameSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args)> FormatChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMultiSourceMediaFrameReaderEvents + { + private readonly global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMultiSourceMediaFrameReaderEvents(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + } +} + +namespace Windows.Media.Casting +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCastingConnectionEvents Events(this global::Windows.Media.Casting.CastingConnection item) => new RxCastingConnectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCastingDevicePickerEvents Events(this global::Windows.Media.Casting.CastingDevicePicker item) => new RxCastingDevicePickerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCastingConnectionEvents + { + private readonly global::Windows.Media.Casting.CastingConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCastingConnectionEvents(global::Windows.Media.Casting.CastingConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Casting.CastingConnection sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingConnection sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Casting.CastingConnection sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCastingDevicePickerEvents + { + private readonly global::Windows.Media.Casting.CastingDevicePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCastingDevicePickerEvents(global::Windows.Media.Casting.CastingDevicePicker data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Casting.CastingDevicePicker sender, object args)> CastingDevicePickerDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingDevicePicker sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CastingDevicePickerDismissed += x, x => _data.CastingDevicePickerDismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args)> CastingDeviceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CastingDeviceSelected += x, x => _data.CastingDeviceSelected -= x); + } +} + +namespace Windows.Media.ContentRestrictions +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRatedContentRestrictionsEvents Events(this global::Windows.Media.ContentRestrictions.RatedContentRestrictions item) => new RxRatedContentRestrictionsEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRatedContentRestrictionsEvents + { + private readonly global::Windows.Media.ContentRestrictions.RatedContentRestrictions _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRatedContentRestrictionsEvents(global::Windows.Media.ContentRestrictions.RatedContentRestrictions data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RestrictionsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.RestrictionsChanged += x, x => _data.RestrictionsChanged -= x); + } +} + +namespace Windows.Media.Control +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGlobalSystemMediaTransportControlsSessionEvents Events(this global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession item) => new RxGlobalSystemMediaTransportControlsSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGlobalSystemMediaTransportControlsSessionManagerEvents Events(this global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager item) => new RxGlobalSystemMediaTransportControlsSessionManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGlobalSystemMediaTransportControlsSessionEvents + { + private readonly global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGlobalSystemMediaTransportControlsSessionEvents(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args)> MediaPropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaPropertiesChanged += x, x => _data.MediaPropertiesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args)> PlaybackInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackInfoChanged += x, x => _data.PlaybackInfoChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args)> TimelinePropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TimelinePropertiesChanged += x, x => _data.TimelinePropertiesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGlobalSystemMediaTransportControlsSessionManagerEvents + { + private readonly global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGlobalSystemMediaTransportControlsSessionManagerEvents(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args)> CurrentSessionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CurrentSessionChanged += x, x => _data.CurrentSessionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args)> SessionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SessionsChanged += x, x => _data.SessionsChanged -= x); + } +} + +namespace Windows.Media.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioTrackEvents Events(this global::Windows.Media.Core.AudioTrack item) => new RxAudioTrackEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFaceDetectionEffectEvents Events(this global::Windows.Media.Core.FaceDetectionEffect item) => new RxFaceDetectionEffectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxISingleSelectMediaTrackListEvents Events(this global::Windows.Media.Core.ISingleSelectMediaTrackList item) => new RxISingleSelectMediaTrackListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaBinderEvents Events(this global::Windows.Media.Core.MediaBinder item) => new RxMediaBinderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaBindingEventArgsEvents Events(this global::Windows.Media.Core.MediaBindingEventArgs item) => new RxMediaBindingEventArgsEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaSourceEvents Events(this global::Windows.Media.Core.MediaSource item) => new RxMediaSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaSourceAppServiceConnectionEvents Events(this global::Windows.Media.Core.MediaSourceAppServiceConnection item) => new RxMediaSourceAppServiceConnectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaStreamSampleEvents Events(this global::Windows.Media.Core.MediaStreamSample item) => new RxMediaStreamSampleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaStreamSourceEvents Events(this global::Windows.Media.Core.MediaStreamSource item) => new RxMediaStreamSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMseSourceBufferEvents Events(this global::Windows.Media.Core.MseSourceBuffer item) => new RxMseSourceBufferEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMseSourceBufferListEvents Events(this global::Windows.Media.Core.MseSourceBufferList item) => new RxMseSourceBufferListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMseStreamSourceEvents Events(this global::Windows.Media.Core.MseStreamSource item) => new RxMseStreamSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSceneAnalysisEffectEvents Events(this global::Windows.Media.Core.SceneAnalysisEffect item) => new RxSceneAnalysisEffectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimedMetadataTrackEvents Events(this global::Windows.Media.Core.TimedMetadataTrack item) => new RxTimedMetadataTrackEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimedTextSourceEvents Events(this global::Windows.Media.Core.TimedTextSource item) => new RxTimedTextSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVideoStabilizationEffectEvents Events(this global::Windows.Media.Core.VideoStabilizationEffect item) => new RxVideoStabilizationEffectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVideoTrackEvents Events(this global::Windows.Media.Core.VideoTrack item) => new RxVideoTrackEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioTrackEvents + { + private readonly global::Windows.Media.Core.AudioTrack _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioTrackEvents(global::Windows.Media.Core.AudioTrack data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args)> OpenFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFaceDetectionEffectEvents + { + private readonly global::Windows.Media.Core.FaceDetectionEffect _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFaceDetectionEffectEvents(global::Windows.Media.Core.FaceDetectionEffect data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args)> FaceDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FaceDetected += x, x => _data.FaceDetected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxISingleSelectMediaTrackListEvents + { + private readonly global::Windows.Media.Core.ISingleSelectMediaTrackList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxISingleSelectMediaTrackListEvents(global::Windows.Media.Core.ISingleSelectMediaTrackList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)> SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaBinderEvents + { + private readonly global::Windows.Media.Core.MediaBinder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaBinderEvents(global::Windows.Media.Core.MediaBinder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args)> Binding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Binding += x, x => _data.Binding -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaBindingEventArgsEvents + { + private readonly global::Windows.Media.Core.MediaBindingEventArgs _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaBindingEventArgsEvents(global::Windows.Media.Core.MediaBindingEventArgs data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaBindingEventArgs sender, object args)> Canceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaBindingEventArgs sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaBindingEventArgs sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Canceled += x, x => _data.Canceled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaSourceEvents + { + private readonly global::Windows.Media.Core.MediaSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaSourceEvents(global::Windows.Media.Core.MediaSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args)> OpenOperationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OpenOperationCompleted += x, x => _data.OpenOperationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaSourceAppServiceConnectionEvents + { + private readonly global::Windows.Media.Core.MediaSourceAppServiceConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaSourceAppServiceConnectionEvents(global::Windows.Media.Core.MediaSourceAppServiceConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args)> InitializeMediaStreamSourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InitializeMediaStreamSourceRequested += x, x => _data.InitializeMediaStreamSourceRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaStreamSampleEvents + { + private readonly global::Windows.Media.Core.MediaStreamSample _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaStreamSampleEvents(global::Windows.Media.Core.MediaStreamSample data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSample sender, object args)> Processed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSample sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSample sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Processed += x, x => _data.Processed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaStreamSourceEvents + { + private readonly global::Windows.Media.Core.MediaStreamSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaStreamSourceEvents(global::Windows.Media.Core.MediaStreamSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, object args)> Paused => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Paused += x, x => _data.Paused -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args)> SampleRendered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SampleRendered += x, x => _data.SampleRendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args)> SampleRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SampleRequested += x, x => _data.SampleRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args)> Starting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Starting += x, x => _data.Starting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args)> SwitchStreamsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SwitchStreamsRequested += x, x => _data.SwitchStreamsRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMseSourceBufferEvents + { + private readonly global::Windows.Media.Core.MseSourceBuffer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMseSourceBufferEvents(global::Windows.Media.Core.MseSourceBuffer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> Aborted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Aborted += x, x => _data.Aborted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> UpdateEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UpdateEnded += x, x => _data.UpdateEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> UpdateStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UpdateStarting += x, x => _data.UpdateStarting -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMseSourceBufferListEvents + { + private readonly global::Windows.Media.Core.MseSourceBufferList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMseSourceBufferListEvents(global::Windows.Media.Core.MseSourceBufferList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBufferList sender, object args)> SourceBufferAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBufferList sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceBufferAdded += x, x => _data.SourceBufferAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseSourceBufferList sender, object args)> SourceBufferRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBufferList sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceBufferRemoved += x, x => _data.SourceBufferRemoved -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMseStreamSourceEvents + { + private readonly global::Windows.Media.Core.MseStreamSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMseStreamSourceEvents(global::Windows.Media.Core.MseStreamSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseStreamSource sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseStreamSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseStreamSource sender, object args)> Ended => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseStreamSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Ended += x, x => _data.Ended -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.MseStreamSource sender, object args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseStreamSource sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSceneAnalysisEffectEvents + { + private readonly global::Windows.Media.Core.SceneAnalysisEffect _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSceneAnalysisEffectEvents(global::Windows.Media.Core.SceneAnalysisEffect data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args)> SceneAnalyzed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SceneAnalyzed += x, x => _data.SceneAnalyzed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimedMetadataTrackEvents + { + private readonly global::Windows.Media.Core.TimedMetadataTrack _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimedMetadataTrackEvents(global::Windows.Media.Core.TimedMetadataTrack data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)> CueEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CueEntered += x, x => _data.CueEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)> CueExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CueExited += x, x => _data.CueExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args)> TrackFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TrackFailed += x, x => _data.TrackFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimedTextSourceEvents + { + private readonly global::Windows.Media.Core.TimedTextSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimedTextSourceEvents(global::Windows.Media.Core.TimedTextSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args)> Resolved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Resolved += x, x => _data.Resolved -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVideoStabilizationEffectEvents + { + private readonly global::Windows.Media.Core.VideoStabilizationEffect _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVideoStabilizationEffectEvents(global::Windows.Media.Core.VideoStabilizationEffect data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args)> EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVideoTrackEvents + { + private readonly global::Windows.Media.Core.VideoTrack _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVideoTrackEvents(global::Windows.Media.Core.VideoTrack data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args)> OpenFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + } +} + +namespace Windows.Media.Devices +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioDeviceModulesManagerEvents Events(this global::Windows.Media.Devices.AudioDeviceModulesManager item) => new RxAudioDeviceModulesManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCallControlEvents Events(this global::Windows.Media.Devices.CallControl item) => new RxCallControlEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioDeviceModulesManagerEvents + { + private readonly global::Windows.Media.Devices.AudioDeviceModulesManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioDeviceModulesManagerEvents(global::Windows.Media.Devices.AudioDeviceModulesManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args)> ModuleNotificationReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ModuleNotificationReceived += x, x => _data.ModuleNotificationReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCallControlEvents + { + private readonly global::Windows.Media.Devices.CallControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCallControlEvents(global::Windows.Media.Devices.CallControl data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnswerRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender) => eventHandler(sender); + return Handler; + }, x => _data.AnswerRequested += x, x => _data.AnswerRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AudioTransferRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender) => eventHandler(sender); + return Handler; + }, x => _data.AudioTransferRequested += x, x => _data.AudioTransferRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.DialRequestedEventArgs e)> DialRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.DialRequestedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.DialRequested += x, x => _data.DialRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HangUpRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender) => eventHandler(sender); + return Handler; + }, x => _data.HangUpRequested += x, x => _data.HangUpRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.KeypadPressedEventArgs e)> KeypadPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.KeypadPressedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.KeypadPressed += x, x => _data.KeypadPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.RedialRequestedEventArgs e)> RedialRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Devices.CallControl sender, global::Windows.Media.Devices.RedialRequestedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.RedialRequested += x, x => _data.RedialRequested -= x); + } +} + +namespace Windows.Media.DialProtocol +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDialDevicePickerEvents Events(this global::Windows.Media.DialProtocol.DialDevicePicker item) => new RxDialDevicePickerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDialDevicePickerEvents + { + private readonly global::Windows.Media.DialProtocol.DialDevicePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDialDevicePickerEvents(global::Windows.Media.DialProtocol.DialDevicePicker data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.DialProtocol.DialDevicePicker sender, object args)> DialDevicePickerDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.DialProtocol.DialDevicePicker sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DialDevicePickerDismissed += x, x => _data.DialDevicePickerDismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args)> DialDeviceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DialDeviceSelected += x, x => _data.DialDeviceSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args)> DisconnectButtonClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + } +} + +namespace Windows.Media.Effects +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioCaptureEffectsManagerEvents Events(this global::Windows.Media.Effects.AudioCaptureEffectsManager item) => new RxAudioCaptureEffectsManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioRenderEffectsManagerEvents Events(this global::Windows.Media.Effects.AudioRenderEffectsManager item) => new RxAudioRenderEffectsManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioCaptureEffectsManagerEvents + { + private readonly global::Windows.Media.Effects.AudioCaptureEffectsManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioCaptureEffectsManagerEvents(global::Windows.Media.Effects.AudioCaptureEffectsManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args)> AudioCaptureEffectsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioCaptureEffectsChanged += x, x => _data.AudioCaptureEffectsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioRenderEffectsManagerEvents + { + private readonly global::Windows.Media.Effects.AudioRenderEffectsManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioRenderEffectsManagerEvents(global::Windows.Media.Effects.AudioRenderEffectsManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args)> AudioRenderEffectsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioRenderEffectsChanged += x, x => _data.AudioRenderEffectsChanged -= x); + } +} + +namespace Windows.Media.Import +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPhotoImportFindItemsResultEvents Events(this global::Windows.Media.Import.PhotoImportFindItemsResult item) => new RxPhotoImportFindItemsResultEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPhotoImportFindItemsResultEvents + { + private readonly global::Windows.Media.Import.PhotoImportFindItemsResult _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPhotoImportFindItemsResultEvents(global::Windows.Media.Import.PhotoImportFindItemsResult data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args)> ItemImported => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemImported += x, x => _data.ItemImported -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args)> SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } +} + +namespace Windows.Media.Miracast +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMiracastReceiverEvents Events(this global::Windows.Media.Miracast.MiracastReceiver item) => new RxMiracastReceiverEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMiracastReceiverCursorImageChannelEvents Events(this global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel item) => new RxMiracastReceiverCursorImageChannelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMiracastReceiverGameControllerDeviceEvents Events(this global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice item) => new RxMiracastReceiverGameControllerDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMiracastReceiverKeyboardDeviceEvents Events(this global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice item) => new RxMiracastReceiverKeyboardDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMiracastReceiverSessionEvents Events(this global::Windows.Media.Miracast.MiracastReceiverSession item) => new RxMiracastReceiverSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMiracastReceiverEvents + { + private readonly global::Windows.Media.Miracast.MiracastReceiver _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMiracastReceiverEvents(global::Windows.Media.Miracast.MiracastReceiver data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiver sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMiracastReceiverCursorImageChannelEvents + { + private readonly global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMiracastReceiverCursorImageChannelEvents(global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args)> ImageStreamChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ImageStreamChanged += x, x => _data.ImageStreamChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args)> PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverCursorImageChannel sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMiracastReceiverGameControllerDeviceEvents + { + private readonly global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMiracastReceiverGameControllerDeviceEvents(global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverGameControllerDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMiracastReceiverKeyboardDeviceEvents + { + private readonly global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMiracastReceiverKeyboardDeviceEvents(global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverKeyboardDevice sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMiracastReceiverSessionEvents + { + private readonly global::Windows.Media.Miracast.MiracastReceiverSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMiracastReceiverSessionEvents(global::Windows.Media.Miracast.MiracastReceiverSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverConnectionCreatedEventArgs args)> ConnectionCreated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverConnectionCreatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverConnectionCreatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionCreated += x, x => _data.ConnectionCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverDisconnectedEventArgs args)> Disconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverDisconnectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverDisconnectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Disconnected += x, x => _data.Disconnected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverMediaSourceCreatedEventArgs args)> MediaSourceCreated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverMediaSourceCreatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Miracast.MiracastReceiverSession sender, global::Windows.Media.Miracast.MiracastReceiverMediaSourceCreatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaSourceCreated += x, x => _data.MediaSourceCreated -= x); + } +} + +namespace Windows.Media.Playback +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaBreakManagerEvents Events(this global::Windows.Media.Playback.MediaBreakManager item) => new RxMediaBreakManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaBreakScheduleEvents Events(this global::Windows.Media.Playback.MediaBreakSchedule item) => new RxMediaBreakScheduleEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackAudioTrackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackAudioTrackList item) => new RxMediaPlaybackAudioTrackListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackCommandManagerEvents Events(this global::Windows.Media.Playback.MediaPlaybackCommandManager item) => new RxMediaPlaybackCommandManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackCommandManagerCommandBehaviorEvents Events(this global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior item) => new RxMediaPlaybackCommandManagerCommandBehaviorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackItemEvents Events(this global::Windows.Media.Playback.MediaPlaybackItem item) => new RxMediaPlaybackItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackList item) => new RxMediaPlaybackListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackSessionEvents Events(this global::Windows.Media.Playback.MediaPlaybackSession item) => new RxMediaPlaybackSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackTimedMetadataTrackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList item) => new RxMediaPlaybackTimedMetadataTrackListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlaybackVideoTrackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackVideoTrackList item) => new RxMediaPlaybackVideoTrackListEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaPlayerEvents Events(this global::Windows.Media.Playback.MediaPlayer item) => new RxMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaBreakManagerEvents + { + private readonly global::Windows.Media.Playback.MediaBreakManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaBreakManagerEvents(global::Windows.Media.Playback.MediaBreakManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args)> BreakEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BreakEnded += x, x => _data.BreakEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args)> BreakSkipped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BreakSkipped += x, x => _data.BreakSkipped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args)> BreaksSeekedOver => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BreaksSeekedOver += x, x => _data.BreaksSeekedOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args)> BreakStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BreakStarted += x, x => _data.BreakStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaBreakScheduleEvents + { + private readonly global::Windows.Media.Playback.MediaBreakSchedule _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaBreakScheduleEvents(global::Windows.Media.Playback.MediaBreakSchedule data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakSchedule sender, object args)> ScheduleChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakSchedule sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaBreakSchedule sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScheduleChanged += x, x => _data.ScheduleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackAudioTrackListEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackAudioTrackList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackAudioTrackListEvents(global::Windows.Media.Playback.MediaPlaybackAudioTrackList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)> SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackCommandManagerEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackCommandManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackCommandManagerEvents(global::Windows.Media.Playback.MediaPlaybackCommandManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args)> AutoRepeatModeReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutoRepeatModeReceived += x, x => _data.AutoRepeatModeReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args)> FastForwardReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FastForwardReceived += x, x => _data.FastForwardReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args)> NextReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NextReceived += x, x => _data.NextReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args)> PauseReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PauseReceived += x, x => _data.PauseReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args)> PlayReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlayReceived += x, x => _data.PlayReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args)> PositionReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionReceived += x, x => _data.PositionReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args)> PreviousReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PreviousReceived += x, x => _data.PreviousReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args)> RateReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RateReceived += x, x => _data.RateReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args)> RewindReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RewindReceived += x, x => _data.RewindReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args)> ShuffleReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShuffleReceived += x, x => _data.ShuffleReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackCommandManagerCommandBehaviorEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackCommandManagerCommandBehaviorEvents(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args)> IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackItemEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackItemEvents(global::Windows.Media.Playback.MediaPlaybackItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)> AudioTracksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioTracksChanged += x, x => _data.AudioTracksChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)> TimedMetadataTracksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TimedMetadataTracksChanged += x, x => _data.TimedMetadataTracksChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)> VideoTracksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoTracksChanged += x, x => _data.VideoTracksChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackListEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackListEvents(global::Windows.Media.Playback.MediaPlaybackList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args)> CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args)> ItemFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemFailed += x, x => _data.ItemFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args)> ItemOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemOpened += x, x => _data.ItemOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackSessionEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackSessionEvents(global::Windows.Media.Playback.MediaPlaybackSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferedRangesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferedRangesChanged += x, x => _data.BufferedRangesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> DownloadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> NaturalDurationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NaturalDurationChanged += x, x => _data.NaturalDurationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> NaturalVideoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NaturalVideoSizeChanged += x, x => _data.NaturalVideoSizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PlaybackRateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackRateChanged += x, x => _data.PlaybackRateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PlaybackStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackStateChanged += x, x => _data.PlaybackStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PlayedRangesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlayedRangesChanged += x, x => _data.PlayedRangesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> SeekableRangesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SeekableRangesChanged += x, x => _data.SeekableRangesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> SeekCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> SupportedPlaybackRatesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SupportedPlaybackRatesChanged += x, x => _data.SupportedPlaybackRatesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackTimedMetadataTrackListEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackTimedMetadataTrackListEvents(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args)> PresentationModeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PresentationModeChanged += x, x => _data.PresentationModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlaybackVideoTrackListEvents + { + private readonly global::Windows.Media.Playback.MediaPlaybackVideoTrackList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlaybackVideoTrackListEvents(global::Windows.Media.Playback.MediaPlaybackVideoTrackList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)> SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaPlayerEvents + { + private readonly global::Windows.Media.Playback.MediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaPlayerEvents(global::Windows.Media.Playback.MediaPlayer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> IsMutedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsMutedChanged += x, x => _data.IsMutedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> MediaEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args)> MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> MediaOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args)> MediaPlayerRateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MediaPlayerRateChanged += x, x => _data.MediaPlayerRateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args)> PlaybackMediaMarkerReached => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackMediaMarkerReached += x, x => _data.PlaybackMediaMarkerReached -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> SeekCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> SourceChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceChanged += x, x => _data.SourceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> SubtitleFrameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SubtitleFrameChanged += x, x => _data.SubtitleFrameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> VideoFrameAvailable => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VideoFrameAvailable += x, x => _data.VideoFrameAvailable -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> VolumeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + } +} + +namespace Windows.Media.PlayTo +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPlayToConnectionEvents Events(this global::Windows.Media.PlayTo.PlayToConnection item) => new RxPlayToConnectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPlayToManagerEvents Events(this global::Windows.Media.PlayTo.PlayToManager item) => new RxPlayToManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPlayToReceiverEvents Events(this global::Windows.Media.PlayTo.PlayToReceiver item) => new RxPlayToReceiverEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPlayToConnectionEvents + { + private readonly global::Windows.Media.PlayTo.PlayToConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPlayToConnectionEvents(global::Windows.Media.PlayTo.PlayToConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args)> Error => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Error += x, x => _data.Error -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args)> Transferred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Transferred += x, x => _data.Transferred -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPlayToManagerEvents + { + private readonly global::Windows.Media.PlayTo.PlayToManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPlayToManagerEvents(global::Windows.Media.PlayTo.PlayToManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args)> SourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceRequested += x, x => _data.SourceRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args)> SourceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceSelected += x, x => _data.SourceSelected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPlayToReceiverEvents + { + private readonly global::Windows.Media.PlayTo.PlayToReceiver _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPlayToReceiverEvents(global::Windows.Media.PlayTo.PlayToReceiver data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args)> CurrentTimeChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CurrentTimeChangeRequested += x, x => _data.CurrentTimeChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args)> MuteChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MuteChangeRequested += x, x => _data.MuteChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> PauseRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PauseRequested += x, x => _data.PauseRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args)> PlaybackRateChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> PlayRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlayRequested += x, x => _data.PlayRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args)> SourceChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceChangeRequested += x, x => _data.SourceChangeRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> StopRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StopRequested += x, x => _data.StopRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> TimeUpdateRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TimeUpdateRequested += x, x => _data.TimeUpdateRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args)> VolumeChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VolumeChangeRequested += x, x => _data.VolumeChangeRequested -= x); + } +} + +namespace Windows.Media.Protection +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHdcpSessionEvents Events(this global::Windows.Media.Protection.HdcpSession item) => new RxHdcpSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaProtectionManagerEvents Events(this global::Windows.Media.Protection.MediaProtectionManager item) => new RxMediaProtectionManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHdcpSessionEvents + { + private readonly global::Windows.Media.Protection.HdcpSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHdcpSessionEvents(global::Windows.Media.Protection.HdcpSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.HdcpSession sender, object args)> ProtectionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.HdcpSession sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.HdcpSession sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProtectionChanged += x, x => _data.ProtectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaProtectionManagerEvents + { + private readonly global::Windows.Media.Protection.MediaProtectionManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaProtectionManagerEvents(global::Windows.Media.Protection.MediaProtectionManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ComponentLoadFailedEventArgs e)> ComponentLoadFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ComponentLoadFailedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.ComponentLoadFailed += x, x => _data.ComponentLoadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RebootNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Protection.MediaProtectionManager sender) => eventHandler(sender); + return Handler; + }, x => _data.RebootNeeded += x, x => _data.RebootNeeded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ServiceRequestedEventArgs e)> ServiceRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ServiceRequestedEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.ServiceRequested += x, x => _data.ServiceRequested -= x); + } +} + +namespace Windows.Media.Protection.PlayReady +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNDClientEvents Events(this global::Windows.Media.Protection.PlayReady.NDClient item) => new RxNDClientEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNDClientEvents + { + private readonly global::Windows.Media.Protection.PlayReady.NDClient _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNDClientEvents(global::Windows.Media.Protection.PlayReady.NDClient data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args)> ClosedCaptionDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ClosedCaptionDataReceived += x, x => _data.ClosedCaptionDataReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args)> LicenseFetchCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LicenseFetchCompleted += x, x => _data.LicenseFetchCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args)> ProximityDetectionCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProximityDetectionCompleted += x, x => _data.ProximityDetectionCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args)> RegistrationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RegistrationCompleted += x, x => _data.RegistrationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, object args)> ReRegistrationNeeded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, object args)>(eventHandler => + { + void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ReRegistrationNeeded += x, x => _data.ReRegistrationNeeded -= x); + } +} + +namespace Windows.Media.SpeechRecognition +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpeechContinuousRecognitionSessionEvents Events(this global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession item) => new RxSpeechContinuousRecognitionSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpeechRecognizerEvents Events(this global::Windows.Media.SpeechRecognition.SpeechRecognizer item) => new RxSpeechRecognizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpeechContinuousRecognitionSessionEvents + { + private readonly global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpeechContinuousRecognitionSessionEvents(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args)> ResultGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResultGenerated += x, x => _data.ResultGenerated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpeechRecognizerEvents + { + private readonly global::Windows.Media.SpeechRecognition.SpeechRecognizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpeechRecognizerEvents(global::Windows.Media.SpeechRecognition.SpeechRecognizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args)> HypothesisGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HypothesisGenerated += x, x => _data.HypothesisGenerated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args)> RecognitionQualityDegrading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RecognitionQualityDegrading += x, x => _data.RecognitionQualityDegrading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace Windows.Media.Streaming.Adaptive +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAdaptiveMediaSourceEvents Events(this global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource item) => new RxAdaptiveMediaSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAdaptiveMediaSourceDiagnosticsEvents Events(this global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics item) => new RxAdaptiveMediaSourceDiagnosticsEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAdaptiveMediaSourceEvents + { + private readonly global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAdaptiveMediaSourceEvents(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args)> DownloadBitrateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadBitrateChanged += x, x => _data.DownloadBitrateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args)> DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args)> DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args)> DownloadRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DownloadRequested += x, x => _data.DownloadRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args)> PlaybackBitrateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PlaybackBitrateChanged += x, x => _data.PlaybackBitrateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAdaptiveMediaSourceDiagnosticsEvents + { + private readonly global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAdaptiveMediaSourceDiagnosticsEvents(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args)> DiagnosticAvailable => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DiagnosticAvailable += x, x => _data.DiagnosticAvailable -= x); + } +} + +namespace Windows.Networking.BackgroundTransfer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDownloadOperationEvents Events(this global::Windows.Networking.BackgroundTransfer.DownloadOperation item) => new RxDownloadOperationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDownloadOperationEvents + { + private readonly global::Windows.Networking.BackgroundTransfer.DownloadOperation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDownloadOperationEvents(global::Windows.Networking.BackgroundTransfer.DownloadOperation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args)> RangesDownloaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RangesDownloaded += x, x => _data.RangesDownloaded -= x); + } +} + +namespace Windows.Networking.NetworkOperators +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxESimEvents Events(this global::Windows.Networking.NetworkOperators.ESim item) => new RxESimEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxESimProfileMetadataEvents Events(this global::Windows.Networking.NetworkOperators.ESimProfileMetadata item) => new RxESimProfileMetadataEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxESimWatcherEvents Events(this global::Windows.Networking.NetworkOperators.ESimWatcher item) => new RxESimWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMobileBroadbandAccountWatcherEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher item) => new RxMobileBroadbandAccountWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMobileBroadbandDeviceServiceDataSessionEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession item) => new RxMobileBroadbandDeviceServiceDataSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMobileBroadbandModemEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandModem item) => new RxMobileBroadbandModemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMobileBroadbandSarManagerEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager item) => new RxMobileBroadbandSarManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxESimEvents + { + private readonly global::Windows.Networking.NetworkOperators.ESim _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxESimEvents(global::Windows.Networking.NetworkOperators.ESim data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESim sender, object args)> ProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESim sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESim sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProfileChanged += x, x => _data.ProfileChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxESimProfileMetadataEvents + { + private readonly global::Windows.Networking.NetworkOperators.ESimProfileMetadata _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxESimProfileMetadataEvents(global::Windows.Networking.NetworkOperators.ESimProfileMetadata data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxESimWatcherEvents + { + private readonly global::Windows.Networking.NetworkOperators.ESimWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxESimWatcherEvents(global::Windows.Networking.NetworkOperators.ESimWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMobileBroadbandAccountWatcherEvents + { + private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMobileBroadbandAccountWatcherEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)> AccountAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccountAdded += x, x => _data.AccountAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)> AccountRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccountRemoved += x, x => _data.AccountRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args)> AccountUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccountUpdated += x, x => _data.AccountUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMobileBroadbandDeviceServiceDataSessionEvents + { + private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMobileBroadbandDeviceServiceDataSessionEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args)> DataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMobileBroadbandModemEvents + { + private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandModem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMobileBroadbandModemEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandModem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args)> IsInEmergencyCallModeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsInEmergencyCallModeChanged += x, x => _data.IsInEmergencyCallModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMobileBroadbandSarManagerEvents + { + private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMobileBroadbandSarManagerEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args)> TransmissionStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransmissionStateChanged += x, x => _data.TransmissionStateChanged -= x); + } +} + +namespace Windows.Networking.Proximity +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPeerWatcherEvents Events(this global::Windows.Networking.Proximity.PeerWatcher item) => new RxPeerWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProximityDeviceEvents Events(this global::Windows.Networking.Proximity.ProximityDevice item) => new RxProximityDeviceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPeerWatcherEvents + { + private readonly global::Windows.Networking.Proximity.PeerWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPeerWatcherEvents(global::Windows.Networking.Proximity.PeerWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)>(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)>(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)>(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxProximityDeviceEvents + { + private readonly global::Windows.Networking.Proximity.ProximityDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxProximityDeviceEvents(global::Windows.Networking.Proximity.ProximityDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DeviceArrived => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); + return Handler; + }, x => _data.DeviceArrived += x, x => _data.DeviceArrived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DeviceDeparted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); + return Handler; + }, x => _data.DeviceDeparted += x, x => _data.DeviceDeparted -= x); + } +} + +namespace Windows.Networking.PushNotifications +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPushNotificationChannelEvents Events(this global::Windows.Networking.PushNotifications.PushNotificationChannel item) => new RxPushNotificationChannelEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPushNotificationChannelEvents + { + private readonly global::Windows.Networking.PushNotifications.PushNotificationChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPushNotificationChannelEvents(global::Windows.Networking.PushNotifications.PushNotificationChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args)> PushNotificationReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PushNotificationReceived += x, x => _data.PushNotificationReceived -= x); + } +} + +namespace Windows.Networking.ServiceDiscovery.Dnssd +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDnssdServiceWatcherEvents Events(this global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher item) => new RxDnssdServiceWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDnssdServiceWatcherEvents + { + private readonly global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDnssdServiceWatcherEvents(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args)>(eventHandler => + { + void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } +} + +namespace Windows.Networking.Sockets +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatagramSocketEvents Events(this global::Windows.Networking.Sockets.DatagramSocket item) => new RxDatagramSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIWebSocketEvents Events(this global::Windows.Networking.Sockets.IWebSocket item) => new RxIWebSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMessageWebSocketEvents Events(this global::Windows.Networking.Sockets.MessageWebSocket item) => new RxMessageWebSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxServerMessageWebSocketEvents Events(this global::Windows.Networking.Sockets.ServerMessageWebSocket item) => new RxServerMessageWebSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxServerStreamWebSocketEvents Events(this global::Windows.Networking.Sockets.ServerStreamWebSocket item) => new RxServerStreamWebSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStreamSocketListenerEvents Events(this global::Windows.Networking.Sockets.StreamSocketListener item) => new RxStreamSocketListenerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStreamWebSocketEvents Events(this global::Windows.Networking.Sockets.StreamWebSocket item) => new RxStreamWebSocketEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatagramSocketEvents + { + private readonly global::Windows.Networking.Sockets.DatagramSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatagramSocketEvents(global::Windows.Networking.Sockets.DatagramSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIWebSocketEvents + { + private readonly global::Windows.Networking.Sockets.IWebSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIWebSocketEvents(global::Windows.Networking.Sockets.IWebSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMessageWebSocketEvents + { + private readonly global::Windows.Networking.Sockets.MessageWebSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMessageWebSocketEvents(global::Windows.Networking.Sockets.MessageWebSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)> ServerCustomValidationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxServerMessageWebSocketEvents + { + private readonly global::Windows.Networking.Sockets.ServerMessageWebSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxServerMessageWebSocketEvents(global::Windows.Networking.Sockets.ServerMessageWebSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxServerStreamWebSocketEvents + { + private readonly global::Windows.Networking.Sockets.ServerStreamWebSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxServerStreamWebSocketEvents(global::Windows.Networking.Sockets.ServerStreamWebSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStreamSocketListenerEvents + { + private readonly global::Windows.Networking.Sockets.StreamSocketListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStreamSocketListenerEvents(global::Windows.Networking.Sockets.StreamSocketListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args)> ConnectionReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ConnectionReceived += x, x => _data.ConnectionReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStreamWebSocketEvents + { + private readonly global::Windows.Networking.Sockets.StreamWebSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStreamWebSocketEvents(global::Windows.Networking.Sockets.StreamWebSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)> ServerCustomValidationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + } +} + +namespace Windows.Networking.Vpn +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVpnChannelEvents Events(this global::Windows.Networking.Vpn.VpnChannel item) => new RxVpnChannelEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVpnChannelEvents + { + private readonly global::Windows.Networking.Vpn.VpnChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVpnChannelEvents(global::Windows.Networking.Vpn.VpnChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args)> ActivityChange => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActivityChange += x, x => _data.ActivityChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args)> ActivityStateChange => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActivityStateChange += x, x => _data.ActivityStateChange -= x); + } +} + +namespace Windows.Networking.XboxLive +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXboxLiveDeviceAddressEvents Events(this global::Windows.Networking.XboxLive.XboxLiveDeviceAddress item) => new RxXboxLiveDeviceAddressEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXboxLiveEndpointPairEvents Events(this global::Windows.Networking.XboxLive.XboxLiveEndpointPair item) => new RxXboxLiveEndpointPairEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXboxLiveEndpointPairTemplateEvents Events(this global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate item) => new RxXboxLiveEndpointPairTemplateEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXboxLiveDeviceAddressEvents + { + private readonly global::Windows.Networking.XboxLive.XboxLiveDeviceAddress _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXboxLiveDeviceAddressEvents(global::Windows.Networking.XboxLive.XboxLiveDeviceAddress data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.XboxLive.XboxLiveDeviceAddress sender, object args)> SnapshotChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.XboxLive.XboxLiveDeviceAddress sender, object args)>(eventHandler => + { + void Handler(global::Windows.Networking.XboxLive.XboxLiveDeviceAddress sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SnapshotChanged += x, x => _data.SnapshotChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXboxLiveEndpointPairEvents + { + private readonly global::Windows.Networking.XboxLive.XboxLiveEndpointPair _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXboxLiveEndpointPairEvents(global::Windows.Networking.XboxLive.XboxLiveEndpointPair data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.XboxLive.XboxLiveEndpointPair sender, global::Windows.Networking.XboxLive.XboxLiveEndpointPairStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.XboxLive.XboxLiveEndpointPair sender, global::Windows.Networking.XboxLive.XboxLiveEndpointPairStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.XboxLive.XboxLiveEndpointPair sender, global::Windows.Networking.XboxLive.XboxLiveEndpointPairStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXboxLiveEndpointPairTemplateEvents + { + private readonly global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXboxLiveEndpointPairTemplateEvents(global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate sender, global::Windows.Networking.XboxLive.XboxLiveInboundEndpointPairCreatedEventArgs args)> InboundEndpointPairCreated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate sender, global::Windows.Networking.XboxLive.XboxLiveInboundEndpointPairCreatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate sender, global::Windows.Networking.XboxLive.XboxLiveInboundEndpointPairCreatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InboundEndpointPairCreated += x, x => _data.InboundEndpointPairCreated -= x); + } +} + +namespace Windows.Perception.Spatial +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialAnchorEvents Events(this global::Windows.Perception.Spatial.SpatialAnchor item) => new RxSpatialAnchorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialEntityWatcherEvents Events(this global::Windows.Perception.Spatial.SpatialEntityWatcher item) => new RxSpatialEntityWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialLocatorEvents Events(this global::Windows.Perception.Spatial.SpatialLocator item) => new RxSpatialLocatorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialAnchorEvents + { + private readonly global::Windows.Perception.Spatial.SpatialAnchor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialAnchorEvents(global::Windows.Perception.Spatial.SpatialAnchor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args)> RawCoordinateSystemAdjusted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RawCoordinateSystemAdjusted += x, x => _data.RawCoordinateSystemAdjusted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialEntityWatcherEvents + { + private readonly global::Windows.Perception.Spatial.SpatialEntityWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialEntityWatcherEvents(global::Windows.Perception.Spatial.SpatialEntityWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialLocatorEvents + { + private readonly global::Windows.Perception.Spatial.SpatialLocator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialLocatorEvents(global::Windows.Perception.Spatial.SpatialLocator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialLocator sender, object args)> LocatabilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialLocator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LocatabilityChanged += x, x => _data.LocatabilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args)> PositionalTrackingDeactivating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PositionalTrackingDeactivating += x, x => _data.PositionalTrackingDeactivating -= x); + } +} + +namespace Windows.Perception.Spatial.Surfaces +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialSurfaceObserverEvents Events(this global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver item) => new RxSpatialSurfaceObserverEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialSurfaceObserverEvents + { + private readonly global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialSurfaceObserverEvents(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args)> ObservedSurfacesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args)>(eventHandler => + { + void Handler(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ObservedSurfacesChanged += x, x => _data.ObservedSurfacesChanged -= x); + } +} + +namespace Windows.Phone.Devices.Power +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBatteryEvents Events(this global::Windows.Phone.Devices.Power.Battery item) => new RxBatteryEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBatteryEvents + { + private readonly global::Windows.Phone.Devices.Power.Battery _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBatteryEvents(global::Windows.Phone.Devices.Power.Battery data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemainingChargePercentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.RemainingChargePercentChanged += x, x => _data.RemainingChargePercentChanged -= x); + } +} + +namespace Windows.Phone.Media.Devices +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAudioRoutingManagerEvents Events(this global::Windows.Phone.Media.Devices.AudioRoutingManager item) => new RxAudioRoutingManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAudioRoutingManagerEvents + { + private readonly global::Windows.Phone.Media.Devices.AudioRoutingManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAudioRoutingManagerEvents(global::Windows.Phone.Media.Devices.AudioRoutingManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args)> AudioEndpointChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioEndpointChanged += x, x => _data.AudioEndpointChanged -= x); + } +} + +namespace Windows.Security.Authentication.Web.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebAccountMonitorEvents Events(this global::Windows.Security.Authentication.Web.Core.WebAccountMonitor item) => new RxWebAccountMonitorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebAccountMonitorEvents + { + private readonly global::Windows.Security.Authentication.Web.Core.WebAccountMonitor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebAccountMonitorEvents(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)> AccountPictureUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccountPictureUpdated += x, x => _data.AccountPictureUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args)> DefaultSignInAccountChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args)>(eventHandler => + { + void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DefaultSignInAccountChanged += x, x => _data.DefaultSignInAccountChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace Windows.Security.Authorization.AppCapabilityAccess +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppCapabilityEvents Events(this global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability item) => new RxAppCapabilityEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppCapabilityEvents + { + private readonly global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppCapabilityEvents(global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability sender, global::Windows.Security.Authorization.AppCapabilityAccess.AppCapabilityAccessChangedEventArgs args)> AccessChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability sender, global::Windows.Security.Authorization.AppCapabilityAccess.AppCapabilityAccessChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Security.Authorization.AppCapabilityAccess.AppCapability sender, global::Windows.Security.Authorization.AppCapabilityAccess.AppCapabilityAccessChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessChanged += x, x => _data.AccessChanged -= x); + } +} + +namespace Windows.Security.Credentials +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordCredentialPropertyStoreEvents Events(this global::Windows.Security.Credentials.PasswordCredentialPropertyStore item) => new RxPasswordCredentialPropertyStoreEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordCredentialPropertyStoreEvents + { + private readonly global::Windows.Security.Credentials.PasswordCredentialPropertyStore _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordCredentialPropertyStoreEvents(global::Windows.Security.Credentials.PasswordCredentialPropertyStore data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } +} + +namespace Windows.Security.DataProtection +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserDataProtectionManagerEvents Events(this global::Windows.Security.DataProtection.UserDataProtectionManager item) => new RxUserDataProtectionManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserDataProtectionManagerEvents + { + private readonly global::Windows.Security.DataProtection.UserDataProtectionManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserDataProtectionManagerEvents(global::Windows.Security.DataProtection.UserDataProtectionManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Security.DataProtection.UserDataProtectionManager sender, global::Windows.Security.DataProtection.UserDataAvailabilityStateChangedEventArgs args)> DataAvailabilityStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.DataProtection.UserDataProtectionManager sender, global::Windows.Security.DataProtection.UserDataAvailabilityStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Security.DataProtection.UserDataProtectionManager sender, global::Windows.Security.DataProtection.UserDataAvailabilityStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataAvailabilityStateChanged += x, x => _data.DataAvailabilityStateChanged -= x); + } +} + +namespace Windows.Services.Maps.Guidance +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGuidanceNavigatorEvents Events(this global::Windows.Services.Maps.Guidance.GuidanceNavigator item) => new RxGuidanceNavigatorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGuidanceNavigatorEvents + { + private readonly global::Windows.Services.Maps.Guidance.GuidanceNavigator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGuidanceNavigatorEvents(global::Windows.Services.Maps.Guidance.GuidanceNavigator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceAudioNotificationRequestedEventArgs args)> AudioNotificationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceAudioNotificationRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceAudioNotificationRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AudioNotificationRequested += x, x => _data.AudioNotificationRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)> DestinationReached => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DestinationReached += x, x => _data.DestinationReached -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs args)> GuidanceUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GuidanceUpdated += x, x => _data.GuidanceUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceReroutedEventArgs args)> Rerouted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceReroutedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, global::Windows.Services.Maps.Guidance.GuidanceReroutedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Rerouted += x, x => _data.Rerouted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)> RerouteFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RerouteFailed += x, x => _data.RerouteFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)> Rerouting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Rerouting += x, x => _data.Rerouting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)> UserLocationLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserLocationLost += x, x => _data.UserLocationLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)> UserLocationRestored => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.Guidance.GuidanceNavigator sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UserLocationRestored += x, x => _data.UserLocationRestored -= x); + } +} + +namespace Windows.Services.Maps.OfflineMaps +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxOfflineMapPackageEvents Events(this global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage item) => new RxOfflineMapPackageEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxOfflineMapPackageEvents + { + private readonly global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxOfflineMapPackageEvents(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } +} + +namespace Windows.Services.Store +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStoreContextEvents Events(this global::Windows.Services.Store.StoreContext item) => new RxStoreContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorePackageLicenseEvents Events(this global::Windows.Services.Store.StorePackageLicense item) => new RxStorePackageLicenseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStoreQueueItemEvents Events(this global::Windows.Services.Store.StoreQueueItem item) => new RxStoreQueueItemEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStoreContextEvents + { + private readonly global::Windows.Services.Store.StoreContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStoreContextEvents(global::Windows.Services.Store.StoreContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Store.StoreContext sender, object args)> OfflineLicensesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Store.StoreContext sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Store.StoreContext sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OfflineLicensesChanged += x, x => _data.OfflineLicensesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorePackageLicenseEvents + { + private readonly global::Windows.Services.Store.StorePackageLicense _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorePackageLicenseEvents(global::Windows.Services.Store.StorePackageLicense data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Store.StorePackageLicense sender, object args)> LicenseLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Store.StorePackageLicense sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Store.StorePackageLicense sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LicenseLost += x, x => _data.LicenseLost -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStoreQueueItemEvents + { + private readonly global::Windows.Services.Store.StoreQueueItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStoreQueueItemEvents(global::Windows.Services.Store.StoreQueueItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Store.StoreQueueItem sender, global::Windows.Services.Store.StoreQueueItemCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Store.StoreQueueItem sender, global::Windows.Services.Store.StoreQueueItemCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.Store.StoreQueueItem sender, global::Windows.Services.Store.StoreQueueItemCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.Store.StoreQueueItem sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Store.StoreQueueItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.Services.Store.StoreQueueItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + } +} + +namespace Windows.Services.TargetedContent +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTargetedContentSubscriptionEvents Events(this global::Windows.Services.TargetedContent.TargetedContentSubscription item) => new RxTargetedContentSubscriptionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTargetedContentSubscriptionEvents + { + private readonly global::Windows.Services.TargetedContent.TargetedContentSubscription _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTargetedContentSubscriptionEvents(global::Windows.Services.TargetedContent.TargetedContentSubscription data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentAvailabilityChangedEventArgs args)> AvailabilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentAvailabilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentAvailabilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentChangedEventArgs args)> ContentChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentChanged += x, x => _data.ContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Services.TargetedContent.TargetedContentSubscription sender, global::Windows.Services.TargetedContent.TargetedContentStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + } +} + +namespace Windows.Storage +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationDataEvents Events(this global::Windows.Storage.ApplicationData item) => new RxApplicationDataEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationDataCompositeValueEvents Events(this global::Windows.Storage.ApplicationDataCompositeValue item) => new RxApplicationDataCompositeValueEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationDataContainerSettingsEvents Events(this global::Windows.Storage.ApplicationDataContainerSettings item) => new RxApplicationDataContainerSettingsEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorageLibraryEvents Events(this global::Windows.Storage.StorageLibrary item) => new RxStorageLibraryEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationDataEvents + { + private readonly global::Windows.Storage.ApplicationData _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationDataEvents(global::Windows.Storage.ApplicationData data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.ApplicationData sender, object args)> DataChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.ApplicationData sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.ApplicationData sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationDataCompositeValueEvents + { + private readonly global::Windows.Storage.ApplicationDataCompositeValue _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationDataCompositeValueEvents(global::Windows.Storage.ApplicationDataCompositeValue data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationDataContainerSettingsEvents + { + private readonly global::Windows.Storage.ApplicationDataContainerSettings _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationDataContainerSettingsEvents(global::Windows.Storage.ApplicationDataContainerSettings data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorageLibraryEvents + { + private readonly global::Windows.Storage.StorageLibrary _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorageLibraryEvents(global::Windows.Storage.StorageLibrary data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.StorageLibrary sender, object args)> DefinitionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.StorageLibrary sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.StorageLibrary sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DefinitionChanged += x, x => _data.DefinitionChanged -= x); + } +} + +namespace Windows.Storage.AccessCache +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorageItemMostRecentlyUsedListEvents Events(this global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList item) => new RxStorageItemMostRecentlyUsedListEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorageItemMostRecentlyUsedListEvents + { + private readonly global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorageItemMostRecentlyUsedListEvents(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args)> ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + } +} + +namespace Windows.Storage.BulkAccess +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileInformationEvents Events(this global::Windows.Storage.BulkAccess.FileInformation item) => new RxFileInformationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFolderInformationEvents Events(this global::Windows.Storage.BulkAccess.FolderInformation item) => new RxFolderInformationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIStorageItemInformationEvents Events(this global::Windows.Storage.BulkAccess.IStorageItemInformation item) => new RxIStorageItemInformationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileInformationEvents + { + private readonly global::Windows.Storage.BulkAccess.FileInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileInformationEvents(global::Windows.Storage.BulkAccess.FileInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> PropertiesUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> ThumbnailUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFolderInformationEvents + { + private readonly global::Windows.Storage.BulkAccess.FolderInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFolderInformationEvents(global::Windows.Storage.BulkAccess.FolderInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> PropertiesUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> ThumbnailUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIStorageItemInformationEvents + { + private readonly global::Windows.Storage.BulkAccess.IStorageItemInformation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIStorageItemInformationEvents(global::Windows.Storage.BulkAccess.IStorageItemInformation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> PropertiesUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> ThumbnailUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + } +} + +namespace Windows.Storage.Pickers.Provider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileOpenPickerUIEvents Events(this global::Windows.Storage.Pickers.Provider.FileOpenPickerUI item) => new RxFileOpenPickerUIEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFileSavePickerUIEvents Events(this global::Windows.Storage.Pickers.Provider.FileSavePickerUI item) => new RxFileSavePickerUIEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileOpenPickerUIEvents + { + private readonly global::Windows.Storage.Pickers.Provider.FileOpenPickerUI _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileOpenPickerUIEvents(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args)> FileRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FileRemoved += x, x => _data.FileRemoved -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFileSavePickerUIEvents + { + private readonly global::Windows.Storage.Pickers.Provider.FileSavePickerUI _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFileSavePickerUIEvents(global::Windows.Storage.Pickers.Provider.FileSavePickerUI data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args)> FileNameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FileNameChanged += x, x => _data.FileNameChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args)> TargetFileRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TargetFileRequested += x, x => _data.TargetFileRequested -= x); + } +} + +namespace Windows.Storage.Provider +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCachedFileUpdaterUIEvents Events(this global::Windows.Storage.Provider.CachedFileUpdaterUI item) => new RxCachedFileUpdaterUIEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCachedFileUpdaterUIEvents + { + private readonly global::Windows.Storage.Provider.CachedFileUpdaterUI _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCachedFileUpdaterUIEvents(global::Windows.Storage.Provider.CachedFileUpdaterUI data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args)> FileUpdateRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FileUpdateRequested += x, x => _data.FileUpdateRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args)> UIRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UIRequested += x, x => _data.UIRequested -= x); + } +} + +namespace Windows.Storage.Search +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIStorageQueryResultBaseEvents Events(this global::Windows.Storage.Search.IStorageQueryResultBase item) => new RxIStorageQueryResultBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorageFileQueryResultEvents Events(this global::Windows.Storage.Search.StorageFileQueryResult item) => new RxStorageFileQueryResultEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorageFolderQueryResultEvents Events(this global::Windows.Storage.Search.StorageFolderQueryResult item) => new RxStorageFolderQueryResultEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStorageItemQueryResultEvents Events(this global::Windows.Storage.Search.StorageItemQueryResult item) => new RxStorageItemQueryResultEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIStorageQueryResultBaseEvents + { + private readonly global::Windows.Storage.Search.IStorageQueryResultBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIStorageQueryResultBaseEvents(global::Windows.Storage.Search.IStorageQueryResultBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorageFileQueryResultEvents + { + private readonly global::Windows.Storage.Search.StorageFileQueryResult _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorageFileQueryResultEvents(global::Windows.Storage.Search.StorageFileQueryResult data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorageFolderQueryResultEvents + { + private readonly global::Windows.Storage.Search.StorageFolderQueryResult _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorageFolderQueryResultEvents(global::Windows.Storage.Search.StorageFolderQueryResult data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStorageItemQueryResultEvents + { + private readonly global::Windows.Storage.Search.StorageItemQueryResult _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStorageItemQueryResultEvents(global::Windows.Storage.Search.StorageItemQueryResult data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => + { + void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + } +} + +namespace Windows.System +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppDiagnosticInfoWatcherEvents Events(this global::Windows.System.AppDiagnosticInfoWatcher item) => new RxAppDiagnosticInfoWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppResourceGroupInfoWatcherEvents Events(this global::Windows.System.AppResourceGroupInfoWatcher item) => new RxAppResourceGroupInfoWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherQueueEvents Events(this global::Windows.System.DispatcherQueue item) => new RxDispatcherQueueEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherQueueTimerEvents Events(this global::Windows.System.DispatcherQueueTimer item) => new RxDispatcherQueueTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserWatcherEvents Events(this global::Windows.System.UserWatcher item) => new RxUserWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppDiagnosticInfoWatcherEvents + { + private readonly global::Windows.System.AppDiagnosticInfoWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppDiagnosticInfoWatcherEvents(global::Windows.System.AppDiagnosticInfoWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppResourceGroupInfoWatcherEvents + { + private readonly global::Windows.System.AppResourceGroupInfoWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppResourceGroupInfoWatcherEvents(global::Windows.System.AppResourceGroupInfoWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args)> ExecutionStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ExecutionStateChanged += x, x => _data.ExecutionStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherQueueEvents + { + private readonly global::Windows.System.DispatcherQueue _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherQueueEvents(global::Windows.System.DispatcherQueue data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.DispatcherQueue sender, object args)> ShutdownCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.DispatcherQueue sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.DispatcherQueue sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShutdownCompleted += x, x => _data.ShutdownCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args)> ShutdownStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ShutdownStarting += x, x => _data.ShutdownStarting -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherQueueTimerEvents + { + private readonly global::Windows.System.DispatcherQueueTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherQueueTimerEvents(global::Windows.System.DispatcherQueueTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.DispatcherQueueTimer sender, object args)> Tick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.DispatcherQueueTimer sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.DispatcherQueueTimer sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserWatcherEvents + { + private readonly global::Windows.System.UserWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserWatcherEvents(global::Windows.System.UserWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> AuthenticationStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AuthenticationStatusChanged += x, x => _data.AuthenticationStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args)> AuthenticationStatusChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AuthenticationStatusChanging += x, x => _data.AuthenticationStatusChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } +} + +namespace Windows.System.Diagnostics.DevicePortal +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDevicePortalConnectionEvents Events(this global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection item) => new RxDevicePortalConnectionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDevicePortalConnectionEvents + { + private readonly global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDevicePortalConnectionEvents(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args)> RequestReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + } +} + +namespace Windows.System.Preview +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTwoPanelHingedDevicePosturePreviewEvents Events(this global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview item) => new RxTwoPanelHingedDevicePosturePreviewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTwoPanelHingedDevicePosturePreviewEvents + { + private readonly global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTwoPanelHingedDevicePosturePreviewEvents(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args)> PostureChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PostureChanged += x, x => _data.PostureChanged -= x); + } +} + +namespace Windows.System.RemoteSystems +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSession item) => new RxRemoteSystemSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionControllerEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionController item) => new RxRemoteSystemSessionControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionInvitationListenerEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener item) => new RxRemoteSystemSessionInvitationListenerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionMessageChannelEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel item) => new RxRemoteSystemSessionMessageChannelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionParticipantWatcherEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher item) => new RxRemoteSystemSessionParticipantWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemSessionWatcherEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher item) => new RxRemoteSystemSessionWatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRemoteSystemWatcherEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemWatcher item) => new RxRemoteSystemWatcherEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionEvents(global::Windows.System.RemoteSystems.RemoteSystemSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args)> Disconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Disconnected += x, x => _data.Disconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionControllerEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionControllerEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args)> JoinRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.JoinRequested += x, x => _data.JoinRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionInvitationListenerEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionInvitationListenerEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args)> InvitationReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InvitationReceived += x, x => _data.InvitationReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionMessageChannelEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionMessageChannelEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args)> ValueSetReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValueSetReceived += x, x => _data.ValueSetReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionParticipantWatcherEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionParticipantWatcherEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemSessionWatcherEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemSessionWatcherEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Added += x, x => _data.Added -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Removed += x, x => _data.Removed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Updated += x, x => _data.Updated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRemoteSystemWatcherEvents + { + private readonly global::Windows.System.RemoteSystems.RemoteSystemWatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRemoteSystemWatcherEvents(global::Windows.System.RemoteSystems.RemoteSystemWatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args)> RemoteSystemAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RemoteSystemAdded += x, x => _data.RemoteSystemAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args)> RemoteSystemRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RemoteSystemRemoved += x, x => _data.RemoteSystemRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args)> RemoteSystemUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RemoteSystemUpdated += x, x => _data.RemoteSystemUpdated -= x); + } +} + +namespace Windows.UI.Accessibility +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScreenReaderServiceEvents Events(this global::Windows.UI.Accessibility.ScreenReaderService item) => new RxScreenReaderServiceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScreenReaderServiceEvents + { + private readonly global::Windows.UI.Accessibility.ScreenReaderService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScreenReaderServiceEvents(global::Windows.UI.Accessibility.ScreenReaderService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args)> ScreenReaderPositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScreenReaderPositionChanged += x, x => _data.ScreenReaderPositionChanged -= x); + } +} + +namespace Windows.UI.ApplicationSettings +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAccountsSettingsPaneEvents Events(this global::Windows.UI.ApplicationSettings.AccountsSettingsPane item) => new RxAccountsSettingsPaneEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSettingsPaneEvents Events(this global::Windows.UI.ApplicationSettings.SettingsPane item) => new RxSettingsPaneEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAccountsSettingsPaneEvents + { + private readonly global::Windows.UI.ApplicationSettings.AccountsSettingsPane _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAccountsSettingsPaneEvents(global::Windows.UI.ApplicationSettings.AccountsSettingsPane data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args)> AccountCommandsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccountCommandsRequested += x, x => _data.AccountCommandsRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSettingsPaneEvents + { + private readonly global::Windows.UI.ApplicationSettings.SettingsPane _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSettingsPaneEvents(global::Windows.UI.ApplicationSettings.SettingsPane data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ApplicationSettings.SettingsPane sender, global::Windows.UI.ApplicationSettings.SettingsPaneCommandsRequestedEventArgs args)> CommandsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ApplicationSettings.SettingsPane sender, global::Windows.UI.ApplicationSettings.SettingsPaneCommandsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ApplicationSettings.SettingsPane sender, global::Windows.UI.ApplicationSettings.SettingsPaneCommandsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CommandsRequested += x, x => _data.CommandsRequested -= x); + } +} + +namespace Windows.UI.Composition +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompositionCapabilitiesEvents Events(this global::Windows.UI.Composition.CompositionCapabilities item) => new RxCompositionCapabilitiesEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompositionCommitBatchEvents Events(this global::Windows.UI.Composition.CompositionCommitBatch item) => new RxCompositionCommitBatchEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompositionGraphicsDeviceEvents Events(this global::Windows.UI.Composition.CompositionGraphicsDevice item) => new RxCompositionGraphicsDeviceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompositionScopedBatchEvents Events(this global::Windows.UI.Composition.CompositionScopedBatch item) => new RxCompositionScopedBatchEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompositionCapabilitiesEvents + { + private readonly global::Windows.UI.Composition.CompositionCapabilities _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompositionCapabilitiesEvents(global::Windows.UI.Composition.CompositionCapabilities data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Composition.CompositionCapabilities sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Composition.CompositionCapabilities sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Composition.CompositionCapabilities sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompositionCommitBatchEvents + { + private readonly global::Windows.UI.Composition.CompositionCommitBatch _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompositionCommitBatchEvents(global::Windows.UI.Composition.CompositionCommitBatch data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompositionGraphicsDeviceEvents + { + private readonly global::Windows.UI.Composition.CompositionGraphicsDevice _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompositionGraphicsDeviceEvents(global::Windows.UI.Composition.CompositionGraphicsDevice data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args)> RenderingDeviceReplaced => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RenderingDeviceReplaced += x, x => _data.RenderingDeviceReplaced -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompositionScopedBatchEvents + { + private readonly global::Windows.UI.Composition.CompositionScopedBatch _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompositionScopedBatchEvents(global::Windows.UI.Composition.CompositionScopedBatch data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } +} + +namespace Windows.UI.Composition.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCompositorControllerEvents Events(this global::Windows.UI.Composition.Core.CompositorController item) => new RxCompositorControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCompositorControllerEvents + { + private readonly global::Windows.UI.Composition.Core.CompositorController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCompositorControllerEvents(global::Windows.UI.Composition.Core.CompositorController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Composition.Core.CompositorController sender, object args)> CommitNeeded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Composition.Core.CompositorController sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Composition.Core.CompositorController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CommitNeeded += x, x => _data.CommitNeeded -= x); + } +} + +namespace Windows.UI.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreAcceleratorKeysEvents Events(this global::Windows.UI.Core.CoreAcceleratorKeys item) => new RxCoreAcceleratorKeysEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreComponentInputSourceEvents Events(this global::Windows.UI.Core.CoreComponentInputSource item) => new RxCoreComponentInputSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreDispatcherEvents Events(this global::Windows.UI.Core.CoreDispatcher item) => new RxCoreDispatcherEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreIndependentInputSourceEvents Events(this global::Windows.UI.Core.CoreIndependentInputSource item) => new RxCoreIndependentInputSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreWindowEvents Events(this global::Windows.UI.Core.CoreWindow item) => new RxCoreWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreWindowDialogEvents Events(this global::Windows.UI.Core.CoreWindowDialog item) => new RxCoreWindowDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreWindowFlyoutEvents Events(this global::Windows.UI.Core.CoreWindowFlyout item) => new RxCoreWindowFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICoreAcceleratorKeysEvents Events(this global::Windows.UI.Core.ICoreAcceleratorKeys item) => new RxICoreAcceleratorKeysEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICoreInputSourceBaseEvents Events(this global::Windows.UI.Core.ICoreInputSourceBase item) => new RxICoreInputSourceBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICorePointerInputSourceEvents Events(this global::Windows.UI.Core.ICorePointerInputSource item) => new RxICorePointerInputSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICorePointerRedirectorEvents Events(this global::Windows.UI.Core.ICorePointerRedirector item) => new RxICorePointerRedirectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICoreWindowEvents Events(this global::Windows.UI.Core.ICoreWindow item) => new RxICoreWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSystemNavigationManagerEvents Events(this global::Windows.UI.Core.SystemNavigationManager item) => new RxSystemNavigationManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreAcceleratorKeysEvents + { + private readonly global::Windows.UI.Core.CoreAcceleratorKeys _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreAcceleratorKeysEvents(global::Windows.UI.Core.CoreAcceleratorKeys data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)> AcceleratorKeyActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreComponentInputSourceEvents + { + private readonly global::Windows.UI.Core.CoreComponentInputSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreComponentInputSourceEvents(global::Windows.UI.Core.CoreComponentInputSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.CharacterReceivedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)> ClosestInteractiveBoundsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.CoreWindowEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.InputEnabledEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.KeyEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.KeyEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.CoreWindowEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchHitTesting => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.TouchHitTestingEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreDispatcherEvents + { + private readonly global::Windows.UI.Core.CoreDispatcher _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreDispatcherEvents(global::Windows.UI.Core.CoreDispatcher data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)> AcceleratorKeyActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreIndependentInputSourceEvents + { + private readonly global::Windows.UI.Core.CoreIndependentInputSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreIndependentInputSourceEvents(global::Windows.UI.Core.CoreIndependentInputSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.InputEnabledEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreWindowEvents + { + private readonly global::Windows.UI.Core.CoreWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreWindowEvents(global::Windows.UI.Core.CoreWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)> AutomationProviderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)> CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)> ClosestInteractiveBoundsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)> InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyDown => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyUp => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedAway => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedTo => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, object args)> ResizeCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResizeCompleted += x, x => _data.ResizeCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, object args)> ResizeStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResizeStarted += x, x => _data.ResizeStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)> SizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)> TouchHitTesting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)> VisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreWindowDialogEvents + { + private readonly global::Windows.UI.Core.CoreWindowDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreWindowDialogEvents(global::Windows.UI.Core.CoreWindowDialog data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args)> Showing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Showing += x, x => _data.Showing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreWindowFlyoutEvents + { + private readonly global::Windows.UI.Core.CoreWindowFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreWindowFlyoutEvents(global::Windows.UI.Core.CoreWindowFlyout data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args)> Showing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowPopupShowingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Showing += x, x => _data.Showing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICoreAcceleratorKeysEvents + { + private readonly global::Windows.UI.Core.ICoreAcceleratorKeys _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICoreAcceleratorKeysEvents(global::Windows.UI.Core.ICoreAcceleratorKeys data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)> AcceleratorKeyActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICoreInputSourceBaseEvents + { + private readonly global::Windows.UI.Core.ICoreInputSourceBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICoreInputSourceBaseEvents(global::Windows.UI.Core.ICoreInputSourceBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.InputEnabledEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICorePointerInputSourceEvents + { + private readonly global::Windows.UI.Core.ICorePointerInputSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICorePointerInputSourceEvents(global::Windows.UI.Core.ICorePointerInputSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICorePointerRedirectorEvents + { + private readonly global::Windows.UI.Core.ICorePointerRedirector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICorePointerRedirectorEvents(global::Windows.UI.Core.ICorePointerRedirector data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedAway => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedTo => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICoreWindowEvents + { + private readonly global::Windows.UI.Core.ICoreWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICoreWindowEvents(global::Windows.UI.Core.ICoreWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)> AutomationProviderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)> CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)> InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyDown => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyUp => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)> SizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)> TouchHitTesting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)> VisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSystemNavigationManagerEvents + { + private readonly global::Windows.UI.Core.SystemNavigationManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSystemNavigationManagerEvents(global::Windows.UI.Core.SystemNavigationManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.BackRequestedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.BackRequestedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); + } +} + +namespace Windows.UI.Core.Preview +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSystemNavigationManagerPreviewEvents Events(this global::Windows.UI.Core.Preview.SystemNavigationManagerPreview item) => new RxSystemNavigationManagerPreviewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSystemNavigationManagerPreviewEvents + { + private readonly global::Windows.UI.Core.Preview.SystemNavigationManagerPreview _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSystemNavigationManagerPreviewEvents(global::Windows.UI.Core.Preview.SystemNavigationManagerPreview data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CloseRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.Preview.SystemNavigationCloseRequestedPreviewEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.Preview.SystemNavigationCloseRequestedPreviewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + } +} + +namespace Windows.UI.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEdgeGestureEvents Events(this global::Windows.UI.Input.EdgeGesture item) => new RxEdgeGestureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGestureRecognizerEvents Events(this global::Windows.UI.Input.GestureRecognizer item) => new RxGestureRecognizerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputActivationListenerEvents Events(this global::Windows.UI.Input.InputActivationListener item) => new RxInputActivationListenerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxKeyboardDeliveryInterceptorEvents Events(this global::Windows.UI.Input.KeyboardDeliveryInterceptor item) => new RxKeyboardDeliveryInterceptorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadialControllerEvents Events(this global::Windows.UI.Input.RadialController item) => new RxRadialControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadialControllerMenuItemEvents Events(this global::Windows.UI.Input.RadialControllerMenuItem item) => new RxRadialControllerMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSystemButtonEventControllerEvents Events(this global::Windows.UI.Input.SystemButtonEventController item) => new RxSystemButtonEventControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEdgeGestureEvents + { + private readonly global::Windows.UI.Input.EdgeGesture _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEdgeGestureEvents(global::Windows.UI.Input.EdgeGesture data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)> Canceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Canceled += x, x => _data.Canceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)> Starting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Starting += x, x => _data.Starting -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGestureRecognizerEvents + { + private readonly global::Windows.UI.Input.GestureRecognizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGestureRecognizerEvents(global::Windows.UI.Input.GestureRecognizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args)> CrossSliding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CrossSliding += x, x => _data.CrossSliding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args)> Dragging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Dragging += x, x => _data.Dragging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args)> Holding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Holding += x, x => _data.Holding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args)> ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args)> ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args)> ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args)> ManipulationUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args)> RightTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args)> Tapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Tapped += x, x => _data.Tapped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputActivationListenerEvents + { + private readonly global::Windows.UI.Input.InputActivationListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputActivationListenerEvents(global::Windows.UI.Input.InputActivationListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.InputActivationListener sender, global::Windows.UI.Input.InputActivationListenerActivationChangedEventArgs args)> InputActivationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.InputActivationListener sender, global::Windows.UI.Input.InputActivationListenerActivationChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.InputActivationListener sender, global::Windows.UI.Input.InputActivationListenerActivationChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InputActivationChanged += x, x => _data.InputActivationChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxKeyboardDeliveryInterceptorEvents + { + private readonly global::Windows.UI.Input.KeyboardDeliveryInterceptor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxKeyboardDeliveryInterceptorEvents(global::Windows.UI.Input.KeyboardDeliveryInterceptor data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)> KeyDown => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)> KeyUp => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadialControllerEvents + { + private readonly global::Windows.UI.Input.RadialController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadialControllerEvents(global::Windows.UI.Input.RadialController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args)> ButtonClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ButtonClicked += x, x => _data.ButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args)> ButtonHolding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ButtonHolding += x, x => _data.ButtonHolding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args)> ButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args)> ButtonReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ButtonReleased += x, x => _data.ButtonReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args)> ControlAcquired => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ControlAcquired += x, x => _data.ControlAcquired -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, object args)> ControlLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args)> RotationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RotationChanged += x, x => _data.RotationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args)> ScreenContactContinued => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScreenContactContinued += x, x => _data.ScreenContactContinued -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, object args)> ScreenContactEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScreenContactEnded += x, x => _data.ScreenContactEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args)> ScreenContactStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScreenContactStarted += x, x => _data.ScreenContactStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadialControllerMenuItemEvents + { + private readonly global::Windows.UI.Input.RadialControllerMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadialControllerMenuItemEvents(global::Windows.UI.Input.RadialControllerMenuItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.RadialControllerMenuItem sender, object args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialControllerMenuItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.RadialControllerMenuItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Invoked += x, x => _data.Invoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSystemButtonEventControllerEvents + { + private readonly global::Windows.UI.Input.SystemButtonEventController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSystemButtonEventControllerEvents(global::Windows.UI.Input.SystemButtonEventController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args)> SystemFunctionButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemFunctionButtonPressed += x, x => _data.SystemFunctionButtonPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args)> SystemFunctionButtonReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionButtonEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemFunctionButtonReleased += x, x => _data.SystemFunctionButtonReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockChangedEventArgs args)> SystemFunctionLockChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemFunctionLockChanged += x, x => _data.SystemFunctionLockChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockIndicatorChangedEventArgs args)> SystemFunctionLockIndicatorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockIndicatorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.SystemButtonEventController sender, global::Windows.UI.Input.SystemFunctionLockIndicatorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SystemFunctionLockIndicatorChanged += x, x => _data.SystemFunctionLockIndicatorChanged -= x); + } +} + +namespace Windows.UI.Input.Inking +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkPresenterEvents Events(this global::Windows.UI.Input.Inking.InkPresenter item) => new RxInkPresenterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkStrokeInputEvents Events(this global::Windows.UI.Input.Inking.InkStrokeInput item) => new RxInkStrokeInputEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkUnprocessedInputEvents Events(this global::Windows.UI.Input.Inking.InkUnprocessedInput item) => new RxInkUnprocessedInputEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkPresenterEvents + { + private readonly global::Windows.UI.Input.Inking.InkPresenter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkPresenterEvents(global::Windows.UI.Input.Inking.InkPresenter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args)> StrokesCollected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokesCollected += x, x => _data.StrokesCollected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args)> StrokesErased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokesErased += x, x => _data.StrokesErased -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkStrokeInputEvents + { + private readonly global::Windows.UI.Input.Inking.InkStrokeInput _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkStrokeInputEvents(global::Windows.UI.Input.Inking.InkStrokeInput data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokeCanceled += x, x => _data.StrokeCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeContinued => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokeContinued += x, x => _data.StrokeContinued -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokeEnded += x, x => _data.StrokeEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.StrokeStarted += x, x => _data.StrokeStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkUnprocessedInputEvents + { + private readonly global::Windows.UI.Input.Inking.InkUnprocessedInput _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkUnprocessedInputEvents(global::Windows.UI.Input.Inking.InkUnprocessedInput data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerHovered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerHovered += x, x => _data.PointerHovered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + } +} + +namespace Windows.UI.Input.Inking.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreInkIndependentInputSourceEvents Events(this global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource item) => new RxCoreInkIndependentInputSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreWetStrokeUpdateSourceEvents Events(this global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource item) => new RxCoreWetStrokeUpdateSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreInkIndependentInputSourceEvents + { + private readonly global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreInkIndependentInputSourceEvents(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntering => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerEntering += x, x => _data.PointerEntering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExiting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerExiting += x, x => _data.PointerExiting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerHovering => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerHovering += x, x => _data.PointerHovering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoving => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerMoving += x, x => _data.PointerMoving -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerPressing += x, x => _data.PointerPressing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleasing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PointerReleasing += x, x => _data.PointerReleasing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreWetStrokeUpdateSourceEvents + { + private readonly global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreWetStrokeUpdateSourceEvents(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WetStrokeCanceled += x, x => _data.WetStrokeCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WetStrokeCompleted += x, x => _data.WetStrokeCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeContinuing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WetStrokeContinuing += x, x => _data.WetStrokeContinuing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WetStrokeStarting += x, x => _data.WetStrokeStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeStopping => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WetStrokeStopping += x, x => _data.WetStrokeStopping -= x); + } +} + +namespace Windows.UI.Input.Spatial +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialGestureRecognizerEvents Events(this global::Windows.UI.Input.Spatial.SpatialGestureRecognizer item) => new RxSpatialGestureRecognizerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSpatialInteractionManagerEvents Events(this global::Windows.UI.Input.Spatial.SpatialInteractionManager item) => new RxSpatialInteractionManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialGestureRecognizerEvents + { + private readonly global::Windows.UI.Input.Spatial.SpatialGestureRecognizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialGestureRecognizerEvents(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args)> HoldCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HoldCanceled += x, x => _data.HoldCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args)> HoldCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HoldCompleted += x, x => _data.HoldCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args)> HoldStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HoldStarted += x, x => _data.HoldStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args)> ManipulationCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationCanceled += x, x => _data.ManipulationCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args)> ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args)> ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args)> ManipulationUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args)> NavigationCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCanceled += x, x => _data.NavigationCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args)> NavigationStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationStarted += x, x => _data.NavigationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args)> NavigationUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationUpdated += x, x => _data.NavigationUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args)> RecognitionEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RecognitionEnded += x, x => _data.RecognitionEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args)> RecognitionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RecognitionStarted += x, x => _data.RecognitionStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args)> Tapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Tapped += x, x => _data.Tapped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSpatialInteractionManagerEvents + { + private readonly global::Windows.UI.Input.Spatial.SpatialInteractionManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSpatialInteractionManagerEvents(global::Windows.UI.Input.Spatial.SpatialInteractionManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args)> InteractionDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InteractionDetected += x, x => _data.InteractionDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceDetected += x, x => _data.SourceDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceLost += x, x => _data.SourceLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourcePressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourcePressed += x, x => _data.SourcePressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceReleased += x, x => _data.SourceReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + } +} + +namespace Windows.UI.Notifications +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToastNotificationEvents Events(this global::Windows.UI.Notifications.ToastNotification item) => new RxToastNotificationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToastNotifierEvents Events(this global::Windows.UI.Notifications.ToastNotifier item) => new RxToastNotifierEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToastNotificationEvents + { + private readonly global::Windows.UI.Notifications.ToastNotification _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToastNotificationEvents(global::Windows.UI.Notifications.ToastNotification data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotification sender, object args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotification sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Notifications.ToastNotification sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args)> Dismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args)> Failed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToastNotifierEvents + { + private readonly global::Windows.UI.Notifications.ToastNotifier _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToastNotifierEvents(global::Windows.UI.Notifications.ToastNotifier data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args)> ScheduledToastNotificationShowing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScheduledToastNotificationShowing += x, x => _data.ScheduledToastNotificationShowing -= x); + } +} + +namespace Windows.UI.Notifications.Management +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUserNotificationListenerEvents Events(this global::Windows.UI.Notifications.Management.UserNotificationListener item) => new RxUserNotificationListenerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUserNotificationListenerEvents + { + private readonly global::Windows.UI.Notifications.Management.UserNotificationListener _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUserNotificationListenerEvents(global::Windows.UI.Notifications.Management.UserNotificationListener data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args)> NotificationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NotificationChanged += x, x => _data.NotificationChanged -= x); + } +} + +namespace Windows.UI.StartScreen +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSecondaryTileEvents Events(this global::Windows.UI.StartScreen.SecondaryTile item) => new RxSecondaryTileEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSecondaryTileEvents + { + private readonly global::Windows.UI.StartScreen.SecondaryTile _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSecondaryTileEvents(global::Windows.UI.StartScreen.SecondaryTile data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args)> VisualElementsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisualElementsRequested += x, x => _data.VisualElementsRequested -= x); + } +} + +namespace Windows.UI.Text.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreTextEditContextEvents Events(this global::Windows.UI.Text.Core.CoreTextEditContext item) => new RxCoreTextEditContextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreTextServicesManagerEvents Events(this global::Windows.UI.Text.Core.CoreTextServicesManager item) => new RxCoreTextServicesManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreTextEditContextEvents + { + private readonly global::Windows.UI.Text.Core.CoreTextEditContext _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreTextEditContextEvents(global::Windows.UI.Text.Core.CoreTextEditContext data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args)> CompositionCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CompositionCompleted += x, x => _data.CompositionCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args)> CompositionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CompositionStarted += x, x => _data.CompositionStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)> FocusRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FocusRemoved += x, x => _data.FocusRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args)> FormatUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FormatUpdating += x, x => _data.FormatUpdating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args)> LayoutRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LayoutRequested += x, x => _data.LayoutRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)> NotifyFocusLeaveCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NotifyFocusLeaveCompleted += x, x => _data.NotifyFocusLeaveCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args)> SelectionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionRequested += x, x => _data.SelectionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args)> SelectionUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionUpdating += x, x => _data.SelectionUpdating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args)> TextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextRequested += x, x => _data.TextRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args)> TextUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextUpdating += x, x => _data.TextUpdating -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreTextServicesManagerEvents + { + private readonly global::Windows.UI.Text.Core.CoreTextServicesManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreTextServicesManagerEvents(global::Windows.UI.Text.Core.CoreTextServicesManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args)> InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + } +} + +namespace Windows.UI.ViewManagement +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAccessibilitySettingsEvents Events(this global::Windows.UI.ViewManagement.AccessibilitySettings item) => new RxAccessibilitySettingsEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationViewEvents Events(this global::Windows.UI.ViewManagement.ApplicationView item) => new RxApplicationViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputPaneEvents Events(this global::Windows.UI.ViewManagement.InputPane item) => new RxInputPaneEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStatusBarEvents Events(this global::Windows.UI.ViewManagement.StatusBar item) => new RxStatusBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUISettingsEvents Events(this global::Windows.UI.ViewManagement.UISettings item) => new RxUISettingsEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAccessibilitySettingsEvents + { + private readonly global::Windows.UI.ViewManagement.AccessibilitySettings _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAccessibilitySettingsEvents(global::Windows.UI.ViewManagement.AccessibilitySettings data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args)> HighContrastChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HighContrastChanged += x, x => _data.HighContrastChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationViewEvents + { + private readonly global::Windows.UI.ViewManagement.ApplicationView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationViewEvents(global::Windows.UI.ViewManagement.ApplicationView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args)> Consolidated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Consolidated += x, x => _data.Consolidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.ApplicationView sender, object args)> VisibleBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.ApplicationView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.VisibleBoundsChanged += x, x => _data.VisibleBoundsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputPaneEvents + { + private readonly global::Windows.UI.ViewManagement.InputPane _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputPaneEvents(global::Windows.UI.ViewManagement.InputPane data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)> Hiding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Hiding += x, x => _data.Hiding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)> Showing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Showing += x, x => _data.Showing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStatusBarEvents + { + private readonly global::Windows.UI.ViewManagement.StatusBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStatusBarEvents(global::Windows.UI.ViewManagement.StatusBar data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.StatusBar sender, object args)> Hiding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.StatusBar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Hiding += x, x => _data.Hiding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.StatusBar sender, object args)> Showing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.StatusBar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Showing += x, x => _data.Showing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUISettingsEvents + { + private readonly global::Windows.UI.ViewManagement.UISettings _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUISettingsEvents(global::Windows.UI.ViewManagement.UISettings data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, object args)> AdvancedEffectsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AdvancedEffectsEnabledChanged += x, x => _data.AdvancedEffectsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAnimationsEnabledChangedEventArgs args)> AnimationsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAnimationsEnabledChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAnimationsEnabledChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AnimationsEnabledChanged += x, x => _data.AnimationsEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAutoHideScrollBarsChangedEventArgs args)> AutoHideScrollBarsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAutoHideScrollBarsChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsAutoHideScrollBarsChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AutoHideScrollBarsChanged += x, x => _data.AutoHideScrollBarsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, object args)> ColorValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ColorValuesChanged += x, x => _data.ColorValuesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsMessageDurationChangedEventArgs args)> MessageDurationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsMessageDurationChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, global::Windows.UI.ViewManagement.UISettingsMessageDurationChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MessageDurationChanged += x, x => _data.MessageDurationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, object args)> TextScaleFactorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextScaleFactorChanged += x, x => _data.TextScaleFactorChanged -= x); + } +} + +namespace Windows.UI.ViewManagement.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCoreInputViewEvents Events(this global::Windows.UI.ViewManagement.Core.CoreInputView item) => new RxCoreInputViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCoreInputViewEvents + { + private readonly global::Windows.UI.ViewManagement.Core.CoreInputView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCoreInputViewEvents(global::Windows.UI.ViewManagement.Core.CoreInputView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args)> OcclusionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OcclusionsChanged += x, x => _data.OcclusionsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewHidingEventArgs args)> PrimaryViewHiding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewHidingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewHidingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrimaryViewHiding += x, x => _data.PrimaryViewHiding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewShowingEventArgs args)> PrimaryViewShowing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewShowingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewShowingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrimaryViewShowing += x, x => _data.PrimaryViewShowing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args)> XYFocusTransferredToPrimaryView => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.XYFocusTransferredToPrimaryView += x, x => _data.XYFocusTransferredToPrimaryView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args)> XYFocusTransferringFromPrimaryView => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.XYFocusTransferringFromPrimaryView += x, x => _data.XYFocusTransferringFromPrimaryView -= x); + } +} + +namespace Windows.UI.WebUI +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebUIBackgroundTaskInstanceRuntimeClassEvents Events(this global::Windows.UI.WebUI.WebUIBackgroundTaskInstanceRuntimeClass item) => new RxWebUIBackgroundTaskInstanceRuntimeClassEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebUIViewEvents Events(this global::Windows.UI.WebUI.WebUIView item) => new RxWebUIViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebUIBackgroundTaskInstanceRuntimeClassEvents + { + private readonly global::Windows.UI.WebUI.WebUIBackgroundTaskInstanceRuntimeClass _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebUIBackgroundTaskInstanceRuntimeClassEvents(global::Windows.UI.WebUI.WebUIBackgroundTaskInstanceRuntimeClass data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason)> Canceled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); + return Handler; + }, x => _data.Canceled += x, x => _data.Canceled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebUIViewEvents + { + private readonly global::Windows.UI.WebUI.WebUIView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebUIViewEvents(global::Windows.UI.WebUI.WebUIView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WebUI.WebUIView sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WebUI.WebUIView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.WebUI.WebUIView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)> ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + } +} + +namespace Windows.UI.WebUI.Core +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebUICommandBarEvents Events(this global::Windows.UI.WebUI.Core.WebUICommandBar item) => new RxWebUICommandBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebUICommandBarConfirmationButtonEvents Events(this global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton item) => new RxWebUICommandBarConfirmationButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebUICommandBarIconButtonEvents Events(this global::Windows.UI.WebUI.Core.WebUICommandBarIconButton item) => new RxWebUICommandBarIconButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebUICommandBarEvents + { + private readonly global::Windows.UI.WebUI.Core.WebUICommandBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebUICommandBarEvents(global::Windows.UI.WebUI.Core.WebUICommandBar data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuClosed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler() => eventHandler(global::System.Reactive.Unit.Default); + return Handler; + }, x => _data.MenuClosed += x, x => _data.MenuClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MenuOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler() => eventHandler(global::System.Reactive.Unit.Default); + return Handler; + }, x => _data.MenuOpened += x, x => _data.MenuOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.UI.WebUI.Core.WebUICommandBarSizeChangedEventArgs eventArgs) => eventHandler(eventArgs); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebUICommandBarConfirmationButtonEvents + { + private readonly global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebUICommandBarConfirmationButtonEvents(global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args)> ItemInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WebUI.Core.WebUICommandBarConfirmationButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebUICommandBarIconButtonEvents + { + private readonly global::Windows.UI.WebUI.Core.WebUICommandBarIconButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebUICommandBarIconButtonEvents(global::Windows.UI.WebUI.Core.WebUICommandBarIconButton data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WebUI.Core.WebUICommandBarIconButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args)> ItemInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WebUI.Core.WebUICommandBarIconButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WebUI.Core.WebUICommandBarIconButton sender, global::Windows.UI.WebUI.Core.WebUICommandBarItemInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + } +} + +namespace Windows.UI.WindowManagement +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppWindowEvents Events(this global::Windows.UI.WindowManagement.AppWindow item) => new RxAppWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDisplayRegionEvents Events(this global::Windows.UI.WindowManagement.DisplayRegion item) => new RxDisplayRegionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowingEnvironmentEvents Events(this global::Windows.UI.WindowManagement.WindowingEnvironment item) => new RxWindowingEnvironmentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppWindowEvents + { + private readonly global::Windows.UI.WindowManagement.AppWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppWindowEvents(global::Windows.UI.WindowManagement.AppWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowChangedEventArgs args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowCloseRequestedEventArgs args)> CloseRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowCloseRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WindowManagement.AppWindow sender, global::Windows.UI.WindowManagement.AppWindowCloseRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDisplayRegionEvents + { + private readonly global::Windows.UI.WindowManagement.DisplayRegion _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDisplayRegionEvents(global::Windows.UI.WindowManagement.DisplayRegion data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WindowManagement.DisplayRegion sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WindowManagement.DisplayRegion sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.WindowManagement.DisplayRegion sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowingEnvironmentEvents + { + private readonly global::Windows.UI.WindowManagement.WindowingEnvironment _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowingEnvironmentEvents(global::Windows.UI.WindowManagement.WindowingEnvironment data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.WindowManagement.WindowingEnvironment sender, global::Windows.UI.WindowManagement.WindowingEnvironmentChangedEventArgs args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WindowManagement.WindowingEnvironment sender, global::Windows.UI.WindowManagement.WindowingEnvironmentChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.WindowManagement.WindowingEnvironment sender, global::Windows.UI.WindowManagement.WindowingEnvironmentChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace Windows.UI.Xaml +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxApplicationEvents Events(this global::Windows.UI.Xaml.Application item) => new RxApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDebugSettingsEvents Events(this global::Windows.UI.Xaml.DebugSettings item) => new RxDebugSettingsEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDependencyObjectCollectionEvents Events(this global::Windows.UI.Xaml.DependencyObjectCollection item) => new RxDependencyObjectCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDispatcherTimerEvents Events(this global::Windows.UI.Xaml.DispatcherTimer item) => new RxDispatcherTimerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameworkElementEvents Events(this global::Windows.UI.Xaml.FrameworkElement item) => new RxFrameworkElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIElementEvents Events(this global::Windows.UI.Xaml.UIElement item) => new RxUIElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVisualStateGroupEvents Events(this global::Windows.UI.Xaml.VisualStateGroup item) => new RxVisualStateGroupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWindowEvents Events(this global::Windows.UI.Xaml.Window item) => new RxWindowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlRootEvents Events(this global::Windows.UI.Xaml.XamlRoot item) => new RxXamlRootEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxApplicationEvents + { + private readonly global::Windows.UI.Xaml.Application _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxApplicationEvents(global::Windows.UI.Xaml.Application data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EnteredBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EnteredBackground += x, x => _data.EnteredBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LeavingBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LeavingBackground += x, x => _data.LeavingBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Resuming => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Resuming += x, x => _data.Resuming -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Suspending => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Suspending += x, x => _data.Suspending -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.UnhandledExceptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDebugSettingsEvents + { + private readonly global::Windows.UI.Xaml.DebugSettings _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDebugSettingsEvents(global::Windows.UI.Xaml.DebugSettings data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BindingFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.BindingFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BindingFailed += x, x => _data.BindingFailed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDependencyObjectCollectionEvents + { + private readonly global::Windows.UI.Xaml.DependencyObjectCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDependencyObjectCollectionEvents(global::Windows.UI.Xaml.DependencyObjectCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event)> VectorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDispatcherTimerEvents + { + private readonly global::Windows.UI.Xaml.DispatcherTimer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDispatcherTimerEvents(global::Windows.UI.Xaml.DispatcherTimer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Tick += x, x => _data.Tick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameworkElementEvents : global::Windows.UI.Xaml.RxUIElementEvents + { + private readonly global::Windows.UI.Xaml.FrameworkElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameworkElementEvents(global::Windows.UI.Xaml.FrameworkElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.FrameworkElement sender, object args)> ActualThemeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.FrameworkElement sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.FrameworkElement sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActualThemeChanged += x, x => _data.ActualThemeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args)> EffectiveViewportChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EffectiveViewportChanged += x, x => _data.EffectiveViewportChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.FrameworkElement sender, object args)> Loading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.FrameworkElement sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.FrameworkElement sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Loading += x, x => _data.Loading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIElementEvents + { + private readonly global::Windows.UI.Xaml.UIElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIElementEvents(global::Windows.UI.Xaml.UIElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)> AccessKeyDisplayDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)> AccessKeyDisplayRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)> AccessKeyInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args)> BringIntoViewRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BringIntoViewRequested += x, x => _data.BringIntoViewRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args)> CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args)> ContextCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContextCanceled += x, x => _data.ContextCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args)> ContextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContextRequested += x, x => _data.ContextRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleTapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args)> DragStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DragStarting += x, x => _data.DragStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args)> DropCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DropCompleted += x, x => _data.DropCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args)> GettingFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GettingFocus += x, x => _data.GettingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Holding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.HoldingRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Holding += x, x => _data.Holding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args)> LosingFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args)> NoFocusCandidateFound => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NoFocusCandidateFound += x, x => _data.NoFocusCandidateFound -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCanceled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerCanceled += x, x => _data.PointerCanceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args)> ProcessKeyboardAccelerators => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProcessKeyboardAccelerators += x, x => _data.ProcessKeyboardAccelerators -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RightTapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.RightTappedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.TappedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tapped += x, x => _data.Tapped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVisualStateGroupEvents + { + private readonly global::Windows.UI.Xaml.VisualStateGroup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVisualStateGroupEvents(global::Windows.UI.Xaml.VisualStateGroup data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWindowEvents + { + private readonly global::Windows.UI.Xaml.Window _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWindowEvents(global::Windows.UI.Xaml.Window data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.WindowActivatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.WindowSizeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Core.VisibilityChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlRootEvents + { + private readonly global::Windows.UI.Xaml.XamlRoot _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlRootEvents(global::Windows.UI.Xaml.XamlRoot data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.XamlRoot sender, global::Windows.UI.Xaml.XamlRootChangedEventArgs args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.XamlRoot sender, global::Windows.UI.Xaml.XamlRootChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.XamlRoot sender, global::Windows.UI.Xaml.XamlRootChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + } +} + +namespace Windows.UI.Xaml.Controls +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAppBarEvents Events(this global::Windows.UI.Xaml.Controls.AppBar item) => new RxAppBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAutoSuggestBoxEvents Events(this global::Windows.UI.Xaml.Controls.AutoSuggestBox item) => new RxAutoSuggestBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarDatePickerEvents Events(this global::Windows.UI.Xaml.Controls.CalendarDatePicker item) => new RxCalendarDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCalendarViewEvents Events(this global::Windows.UI.Xaml.Controls.CalendarView item) => new RxCalendarViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxColorPickerEvents Events(this global::Windows.UI.Xaml.Controls.ColorPicker item) => new RxColorPickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxComboBoxEvents Events(this global::Windows.UI.Xaml.Controls.ComboBox item) => new RxComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCommandBarEvents Events(this global::Windows.UI.Xaml.Controls.CommandBar item) => new RxCommandBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentDialogEvents Events(this global::Windows.UI.Xaml.Controls.ContentDialog item) => new RxContentDialogEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxControlEvents Events(this global::Windows.UI.Xaml.Controls.Control item) => new RxControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerEvents Events(this global::Windows.UI.Xaml.Controls.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDatePickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.DatePickerFlyout item) => new RxDatePickerFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFrameEvents Events(this global::Windows.UI.Xaml.Controls.Frame item) => new RxFrameEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHandwritingViewEvents Events(this global::Windows.UI.Xaml.Controls.HandwritingView item) => new RxHandwritingViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHubEvents Events(this global::Windows.UI.Xaml.Controls.Hub item) => new RxHubEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageEvents Events(this global::Windows.UI.Xaml.Controls.Image item) => new RxImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkToolbarEvents Events(this global::Windows.UI.Xaml.Controls.InkToolbar item) => new RxInkToolbarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInkToolbarFlyoutItemEvents Events(this global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem item) => new RxInkToolbarFlyoutItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemCollectionEvents Events(this global::Windows.UI.Xaml.Controls.ItemCollection item) => new RxItemCollectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemContainerGeneratorEvents Events(this global::Windows.UI.Xaml.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxItemsPresenterEvents Events(this global::Windows.UI.Xaml.Controls.ItemsPresenter item) => new RxItemsPresenterEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListPickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.ListPickerFlyout item) => new RxListPickerFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxListViewBaseEvents Events(this global::Windows.UI.Xaml.Controls.ListViewBase item) => new RxListViewBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::Windows.UI.Xaml.Controls.MediaElement item) => new RxMediaElementEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaTransportControlsEvents Events(this global::Windows.UI.Xaml.Controls.MediaTransportControls item) => new RxMediaTransportControlsEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMenuFlyoutItemEvents Events(this global::Windows.UI.Xaml.Controls.MenuFlyoutItem item) => new RxMenuFlyoutItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNavigationViewEvents Events(this global::Windows.UI.Xaml.Controls.NavigationView item) => new RxNavigationViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPasswordBoxEvents Events(this global::Windows.UI.Xaml.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.PickerFlyout item) => new RxPickerFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPivotEvents Events(this global::Windows.UI.Xaml.Controls.Pivot item) => new RxPivotEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRatingControlEvents Events(this global::Windows.UI.Xaml.Controls.RatingControl item) => new RxRatingControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRefreshContainerEvents Events(this global::Windows.UI.Xaml.Controls.RefreshContainer item) => new RxRefreshContainerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRefreshVisualizerEvents Events(this global::Windows.UI.Xaml.Controls.RefreshVisualizer item) => new RxRefreshVisualizerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichEditBoxEvents Events(this global::Windows.UI.Xaml.Controls.RichEditBox item) => new RxRichEditBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBlockEvents Events(this global::Windows.UI.Xaml.Controls.RichTextBlock item) => new RxRichTextBlockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRichTextBlockOverflowEvents Events(this global::Windows.UI.Xaml.Controls.RichTextBlockOverflow item) => new RxRichTextBlockOverflowEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollViewerEvents Events(this global::Windows.UI.Xaml.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSearchBoxEvents Events(this global::Windows.UI.Xaml.Controls.SearchBox item) => new RxSearchBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSemanticZoomEvents Events(this global::Windows.UI.Xaml.Controls.SemanticZoom item) => new RxSemanticZoomEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSettingsFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.SettingsFlyout item) => new RxSettingsFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitButtonEvents Events(this global::Windows.UI.Xaml.Controls.SplitButton item) => new RxSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSplitViewEvents Events(this global::Windows.UI.Xaml.Controls.SplitView item) => new RxSplitViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStackPanelEvents Events(this global::Windows.UI.Xaml.Controls.StackPanel item) => new RxStackPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSwapChainPanelEvents Events(this global::Windows.UI.Xaml.Controls.SwapChainPanel item) => new RxSwapChainPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSwipeItemEvents Events(this global::Windows.UI.Xaml.Controls.SwipeItem item) => new RxSwipeItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBlockEvents Events(this global::Windows.UI.Xaml.Controls.TextBlock item) => new RxTextBlockEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextBoxEvents Events(this global::Windows.UI.Xaml.Controls.TextBox item) => new RxTextBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimePickerEvents Events(this global::Windows.UI.Xaml.Controls.TimePicker item) => new RxTimePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimePickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.TimePickerFlyout item) => new RxTimePickerFlyoutEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleSplitButtonEvents Events(this global::Windows.UI.Xaml.Controls.ToggleSplitButton item) => new RxToggleSplitButtonEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleSwitchEvents Events(this global::Windows.UI.Xaml.Controls.ToggleSwitch item) => new RxToggleSwitchEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToolTipEvents Events(this global::Windows.UI.Xaml.Controls.ToolTip item) => new RxToolTipEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTreeViewEvents Events(this global::Windows.UI.Xaml.Controls.TreeView item) => new RxTreeViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTwoPaneViewEvents Events(this global::Windows.UI.Xaml.Controls.TwoPaneView item) => new RxTwoPaneViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxVirtualizingStackPanelEvents Events(this global::Windows.UI.Xaml.Controls.VirtualizingStackPanel item) => new RxVirtualizingStackPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebViewEvents Events(this global::Windows.UI.Xaml.Controls.WebView item) => new RxWebViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAppBarEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.AppBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAppBarEvents(global::Windows.UI.Xaml.Controls.AppBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAutoSuggestBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.AutoSuggestBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAutoSuggestBoxEvents(global::Windows.UI.Xaml.Controls.AutoSuggestBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args)> QuerySubmitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args)> SuggestionChosen => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SuggestionChosen += x, x => _data.SuggestionChosen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args)> TextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarDatePickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.CalendarDatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarDatePickerEvents(global::Windows.UI.Xaml.Controls.CalendarDatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs e)> CalendarViewDayItemChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs e) => eventHandler((sender, e)); + return Handler; + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args)> DateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCalendarViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.CalendarView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCalendarViewEvents(global::Windows.UI.Xaml.Controls.CalendarView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args)> CalendarViewDayItemChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args)> SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxColorPickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.ColorPicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxColorPickerEvents(global::Windows.UI.Xaml.Controls.ColorPicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)> ColorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxComboBoxEvents : global::Windows.UI.Xaml.Controls.Primitives.RxSelectorEvents + { + private readonly global::Windows.UI.Xaml.Controls.ComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxComboBoxEvents(global::Windows.UI.Xaml.Controls.ComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args)> TextSubmitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextSubmitted += x, x => _data.TextSubmitted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCommandBarEvents : global::Windows.UI.Xaml.Controls.RxAppBarEvents + { + private readonly global::Windows.UI.Xaml.Controls.CommandBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCommandBarEvents(global::Windows.UI.Xaml.Controls.CommandBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args)> DynamicOverflowItemsChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DynamicOverflowItemsChanging += x, x => _data.DynamicOverflowItemsChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentDialogEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.ContentDialog _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentDialogEvents(global::Windows.UI.Xaml.Controls.ContentDialog data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)> CloseButtonClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CloseButtonClick += x, x => _data.CloseButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)> PrimaryButtonClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrimaryButtonClick += x, x => _data.PrimaryButtonClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)> SecondaryButtonClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SecondaryButtonClick += x, x => _data.SecondaryButtonClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxControlEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Control _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxControlEvents(global::Windows.UI.Xaml.Controls.Control data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args)> FocusDisengaged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FocusDisengaged += x, x => _data.FocusDisengaged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args)> FocusEngaged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FocusEngaged += x, x => _data.FocusEngaged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.DatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerEvents(global::Windows.UI.Xaml.Controls.DatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args)> SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDatePickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.DatePickerFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDatePickerFlyoutEvents(global::Windows.UI.Xaml.Controls.DatePickerFlyout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args)> DatePicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DatePicked += x, x => _data.DatePicked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFrameEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Frame _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFrameEvents(global::Windows.UI.Xaml.Controls.Frame data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigated += x, x => _data.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Navigating += x, x => _data.Navigating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHandwritingViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.HandwritingView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHandwritingViewEvents(global::Windows.UI.Xaml.Controls.HandwritingView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHubEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Hub _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHubEvents(global::Windows.UI.Xaml.Controls.Hub data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SectionHeaderClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.HubSectionHeaderClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SectionHeaderClick += x, x => _data.SectionHeaderClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SectionsInViewChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SectionsInViewChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SectionsInViewChanged += x, x => _data.SectionsInViewChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Image _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageEvents(global::Windows.UI.Xaml.Controls.Image data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkToolbarEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.InkToolbar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkToolbarEvents(global::Windows.UI.Xaml.Controls.InkToolbar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> ActiveToolChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActiveToolChanged += x, x => _data.ActiveToolChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> EraseAllClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.EraseAllClicked += x, x => _data.EraseAllClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> InkDrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.InkDrawingAttributesChanged += x, x => _data.InkDrawingAttributesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> IsRulerButtonCheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsRulerButtonCheckedChanged += x, x => _data.IsRulerButtonCheckedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args)> IsStencilButtonCheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsStencilButtonCheckedChanged += x, x => _data.IsStencilButtonCheckedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInkToolbarFlyoutItemEvents : global::Windows.UI.Xaml.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInkToolbarFlyoutItemEvents(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)> Checked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)> Unchecked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemCollectionEvents + { + private readonly global::Windows.UI.Xaml.Controls.ItemCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemCollectionEvents(global::Windows.UI.Xaml.Controls.ItemCollection data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event)> VectorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event)>(eventHandler => + { + void Handler(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event) => eventHandler((sender, @event)); + return Handler; + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemContainerGeneratorEvents + { + private readonly global::Windows.UI.Xaml.Controls.ItemContainerGenerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemContainerGeneratorEvents(global::Windows.UI.Xaml.Controls.ItemContainerGenerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxItemsPresenterEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.ItemsPresenter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxItemsPresenterEvents(global::Windows.UI.Xaml.Controls.ItemsPresenter data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListPickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.ListPickerFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListPickerFlyoutEvents(global::Windows.UI.Xaml.Controls.ListPickerFlyout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args)> ItemsPicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemsPicked += x, x => _data.ItemsPicked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxListViewBaseEvents : global::Windows.UI.Xaml.Controls.Primitives.RxSelectorEvents + { + private readonly global::Windows.UI.Xaml.Controls.ListViewBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxListViewBaseEvents(global::Windows.UI.Xaml.Controls.ListViewBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args)> ChoosingGroupHeaderContainer => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ChoosingGroupHeaderContainer += x, x => _data.ChoosingGroupHeaderContainer -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args)> ChoosingItemContainer => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ChoosingItemContainer += x, x => _data.ChoosingItemContainer -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args)> ContainerContentChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContainerContentChanging += x, x => _data.ContainerContentChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args)> DragItemsCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragItemsStarting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.DragItemsStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ItemClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::Windows.UI.Xaml.Controls.MediaElement data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MarkerReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Media.TimelineMarkerRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MarkerReached += x, x => _data.MarkerReached -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args)> PartialMediaFailureDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PartialMediaFailureDetected += x, x => _data.PartialMediaFailureDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Media.RateChangedRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RateChanged += x, x => _data.RateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SeekCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VolumeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaTransportControlsEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.MediaTransportControls _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaTransportControlsEvents(global::Windows.UI.Xaml.Controls.MediaTransportControls data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args)> ThumbnailRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ThumbnailRequested += x, x => _data.ThumbnailRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMenuFlyoutItemEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.MenuFlyoutItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMenuFlyoutItemEvents(global::Windows.UI.Xaml.Controls.MenuFlyoutItem data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNavigationViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.NavigationView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNavigationViewEvents(global::Windows.UI.Xaml.Controls.NavigationView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args)> BackRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args)> DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args)> ItemInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, object args)> PaneClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args)> PaneClosing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, object args)> PaneOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, object args)> PaneOpening => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args)> SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPasswordBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.PasswordBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPasswordBoxEvents(global::Windows.UI.Xaml.Controls.PasswordBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args)> PasswordChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PasswordChanging += x, x => _data.PasswordChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paste => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paste += x, x => _data.Paste -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.PickerFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPickerFlyoutEvents(global::Windows.UI.Xaml.Controls.PickerFlyout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args)> Confirmed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Confirmed += x, x => _data.Confirmed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPivotEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Pivot _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPivotEvents(global::Windows.UI.Xaml.Controls.Pivot data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PivotItemLoaded += x, x => _data.PivotItemLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PivotItemLoading += x, x => _data.PivotItemLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemUnloaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PivotItemUnloaded += x, x => _data.PivotItemUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemUnloading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PivotItemUnloading += x, x => _data.PivotItemUnloading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRatingControlEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.RatingControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRatingControlEvents(global::Windows.UI.Xaml.Controls.RatingControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RatingControl sender, object args)> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RatingControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RatingControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRefreshContainerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.RefreshContainer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRefreshContainerEvents(global::Windows.UI.Xaml.Controls.RefreshContainer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)> RefreshRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRefreshVisualizerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.RefreshVisualizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRefreshVisualizerEvents(global::Windows.UI.Xaml.Controls.RefreshVisualizer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)> RefreshRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args)> RefreshStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RefreshStateChanged += x, x => _data.RefreshStateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichEditBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.RichEditBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichEditBoxEvents(global::Windows.UI.Xaml.Controls.RichEditBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)> CandidateWindowBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args)> ContentLinkChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLinkChanged += x, x => _data.ContentLinkChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)> ContentLinkInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLinkInvoked += x, x => _data.ContentLinkInvoked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)> CopyingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)> CuttingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paste => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paste += x, x => _data.Paste -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args)> SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args)> TextChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)> TextCompositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)> TextCompositionEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)> TextCompositionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBlockEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.RichTextBlock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBlockEvents(global::Windows.UI.Xaml.Controls.RichTextBlock data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)> IsTextTrimmedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRichTextBlockOverflowEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.RichTextBlockOverflow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRichTextBlockOverflowEvents(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)> IsTextTrimmedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollViewerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.ScrollViewer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollViewerEvents(global::Windows.UI.Xaml.Controls.ScrollViewer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args)> AnchorRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AnchorRequested += x, x => _data.AnchorRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DirectManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.DirectManipulationCompleted += x, x => _data.DirectManipulationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DirectManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.DirectManipulationStarted += x, x => _data.DirectManipulationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ViewChanged += x, x => _data.ViewChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ViewChanging => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ViewChanging += x, x => _data.ViewChanging -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSearchBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.SearchBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSearchBoxEvents(global::Windows.UI.Xaml.Controls.SearchBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args)> PrepareForFocusOnKeyboardInput => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PrepareForFocusOnKeyboardInput += x, x => _data.PrepareForFocusOnKeyboardInput -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args)> QueryChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QueryChanged += x, x => _data.QueryChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args)> QuerySubmitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args)> ResultSuggestionChosen => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args)> SuggestionsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSemanticZoomEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.SemanticZoom _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSemanticZoomEvents(global::Windows.UI.Xaml.Controls.SemanticZoom data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ViewChangeCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ViewChangeCompleted += x, x => _data.ViewChangeCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ViewChangeStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ViewChangeStarted += x, x => _data.ViewChangeStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSettingsFlyoutEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.SettingsFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSettingsFlyoutEvents(global::Windows.UI.Xaml.Controls.SettingsFlyout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.BackClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackClick += x, x => _data.BackClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitButtonEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.SplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitButtonEvents(global::Windows.UI.Xaml.Controls.SplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args)> Click => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSplitViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.SplitView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSplitViewEvents(global::Windows.UI.Xaml.Controls.SplitView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, object args)> PaneClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args)> PaneClosing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, object args)> PaneOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, object args)> PaneOpening => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStackPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.StackPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStackPanelEvents(global::Windows.UI.Xaml.Controls.StackPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSwapChainPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.SwapChainPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSwapChainPanelEvents(global::Windows.UI.Xaml.Controls.SwapChainPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args)> CompositionScaleChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CompositionScaleChanged += x, x => _data.CompositionScaleChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSwipeItemEvents + { + private readonly global::Windows.UI.Xaml.Controls.SwipeItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSwipeItemEvents(global::Windows.UI.Xaml.Controls.SwipeItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Invoked += x, x => _data.Invoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBlockEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.TextBlock _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBlockEvents(global::Windows.UI.Xaml.Controls.TextBlock data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)> IsTextTrimmedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.TextBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextBoxEvents(global::Windows.UI.Xaml.Controls.TextBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args)> BeforeTextChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BeforeTextChanging += x, x => _data.BeforeTextChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)> CandidateWindowBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)> CopyingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)> CuttingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paste => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paste += x, x => _data.Paste -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args)> SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.TextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args)> TextChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)> TextCompositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)> TextCompositionEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)> TextCompositionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimePickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.TimePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimePickerEvents(global::Windows.UI.Xaml.Controls.TimePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args)> SelectedTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SelectedTimeChanged += x, x => _data.SelectedTimeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TimeChanged += x, x => _data.TimeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimePickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.TimePickerFlyout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimePickerFlyoutEvents(global::Windows.UI.Xaml.Controls.TimePickerFlyout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args)> TimePicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TimePicked += x, x => _data.TimePicked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleSplitButtonEvents : global::Windows.UI.Xaml.Controls.RxSplitButtonEvents + { + private readonly global::Windows.UI.Xaml.Controls.ToggleSplitButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleSplitButtonEvents(global::Windows.UI.Xaml.Controls.ToggleSplitButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args)> IsCheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.IsCheckedChanged += x, x => _data.IsCheckedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleSwitchEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.ToggleSwitch _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleSwitchEvents(global::Windows.UI.Xaml.Controls.ToggleSwitch data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Toggled += x, x => _data.Toggled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToolTipEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.ToolTip _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToolTipEvents(global::Windows.UI.Xaml.Controls.ToolTip data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTreeViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.TreeView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTreeViewEvents(global::Windows.UI.Xaml.Controls.TreeView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args)> Collapsed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args)> DragItemsCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args)> DragItemsStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args)> Expanding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Expanding += x, x => _data.Expanding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args)> ItemInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTwoPaneViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.TwoPaneView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTwoPaneViewEvents(global::Windows.UI.Xaml.Controls.TwoPaneView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TwoPaneView sender, object args)> ModeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TwoPaneView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.TwoPaneView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ModeChanged += x, x => _data.ModeChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxVirtualizingStackPanelEvents : global::Windows.UI.Xaml.Controls.Primitives.RxOrientedVirtualizingPanelEvents + { + private readonly global::Windows.UI.Xaml.Controls.VirtualizingStackPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxVirtualizingStackPanelEvents(global::Windows.UI.Xaml.Controls.VirtualizingStackPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CleanUpVirtualizedItemEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CleanUpVirtualizedItemEvent += x, x => _data.CleanUpVirtualizedItemEvent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebViewEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.WebView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebViewEvents(global::Windows.UI.Xaml.Controls.WebView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.WebViewNavigationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.NotifyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args)> SeparateProcessLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.SeparateProcessLost += x, x => _data.SeparateProcessLost -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + } +} + +namespace Windows.UI.Xaml.Controls.Maps +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCustomMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource item) => new RxCustomMapTileDataSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHttpMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource item) => new RxHttpMapTileDataSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLocalMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource item) => new RxLocalMapTileDataSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMapControlEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapControl item) => new RxMapControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMapControlDataHelperEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapControlDataHelper item) => new RxMapControlDataHelperEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMapElementsLayerEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer item) => new RxMapElementsLayerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMapSceneEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapScene item) => new RxMapSceneEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCustomMapTileDataSourceEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCustomMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args)> BitmapRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHttpMapTileDataSourceEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHttpMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)> UriRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLocalMapTileDataSourceEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLocalMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)> UriRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMapControlEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.MapControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMapControlEvents(global::Windows.UI.Xaml.Controls.Maps.MapControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args)> ActualCameraChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActualCameraChanged += x, x => _data.ActualCameraChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args)> ActualCameraChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ActualCameraChanging += x, x => _data.ActualCameraChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> CenterChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CenterChanged += x, x => _data.CenterChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args)> CustomExperienceChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CustomExperienceChanged += x, x => _data.CustomExperienceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> HeadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.HeadingChanged += x, x => _data.HeadingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> LoadingStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LoadingStatusChanged += x, x => _data.LoadingStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args)> MapContextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)> MapDoubleTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapDoubleTapped += x, x => _data.MapDoubleTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args)> MapElementClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args)> MapElementPointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args)> MapElementPointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)> MapHolding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapHolding += x, x => _data.MapHolding -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args)> MapRightTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapRightTapped += x, x => _data.MapRightTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)> MapTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapTapped += x, x => _data.MapTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> PitchChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PitchChanged += x, x => _data.PitchChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)> TargetCameraChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> TransformOriginChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransformOriginChanged += x, x => _data.TransformOriginChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> ZoomLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ZoomLevelChanged += x, x => _data.ZoomLevelChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMapControlDataHelperEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.MapControlDataHelper _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMapControlDataHelperEvents(global::Windows.UI.Xaml.Controls.Maps.MapControlDataHelper data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkClickEventArgs args)> BusinessLandmarkClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BusinessLandmarkClick += x, x => _data.BusinessLandmarkClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerEnteredEventArgs args)> BusinessLandmarkPointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerEnteredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerEnteredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BusinessLandmarkPointerEntered += x, x => _data.BusinessLandmarkPointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerExitedEventArgs args)> BusinessLandmarkPointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerExitedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerExitedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BusinessLandmarkPointerExited += x, x => _data.BusinessLandmarkPointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkRightTappedEventArgs args)> BusinessLandmarkRightTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkRightTappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkRightTappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.BusinessLandmarkRightTapped += x, x => _data.BusinessLandmarkRightTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureClickEventArgs args)> TransitFeatureClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransitFeatureClick += x, x => _data.TransitFeatureClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerEnteredEventArgs args)> TransitFeaturePointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerEnteredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerEnteredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransitFeaturePointerEntered += x, x => _data.TransitFeaturePointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerExitedEventArgs args)> TransitFeaturePointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerExitedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerExitedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransitFeaturePointerExited += x, x => _data.TransitFeaturePointerExited -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureRightTappedEventArgs args)> TransitFeatureRightTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureRightTappedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureRightTappedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TransitFeatureRightTapped += x, x => _data.TransitFeatureRightTapped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMapElementsLayerEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMapElementsLayerEvents(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args)> MapContextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args)> MapElementClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args)> MapElementPointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args)> MapElementPointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMapSceneEvents + { + private readonly global::Windows.UI.Xaml.Controls.Maps.MapScene _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMapSceneEvents(global::Windows.UI.Xaml.Controls.Maps.MapScene data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)> TargetCameraChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + } +} + +namespace Windows.UI.Xaml.Controls.Primitives +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxButtonBaseEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCarouselPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.CarouselPanel item) => new RxCarouselPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxColorSpectrumEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum item) => new RxColorSpectrumEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFlyoutBaseEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase item) => new RxFlyoutBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIScrollSnapPointsInfoEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo item) => new RxIScrollSnapPointsInfoEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLoopingSelectorEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.LoopingSelector item) => new RxLoopingSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLoopingSelectorPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.LoopingSelectorPanel item) => new RxLoopingSelectorPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxOrientedVirtualizingPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel item) => new RxOrientedVirtualizingPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPivotPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.PivotPanel item) => new RxPivotPanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPopupEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.Popup item) => new RxPopupEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRangeBaseEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxScrollBarEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSelectorEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.Selector item) => new RxSelectorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxThumbEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.Thumb item) => new RxThumbEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxToggleButtonEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxButtonBaseEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.ButtonBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxButtonBaseEvents(global::Windows.UI.Xaml.Controls.Primitives.ButtonBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCarouselPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.CarouselPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCarouselPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.CarouselPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxColorSpectrumEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxColorSpectrumEvents(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)> ColorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFlyoutBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFlyoutBaseEvents(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Closing += x, x => _data.Closing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opening += x, x => _data.Opening -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIScrollSnapPointsInfoEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIScrollSnapPointsInfoEvents(global::Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLoopingSelectorEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.LoopingSelector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLoopingSelectorEvents(global::Windows.UI.Xaml.Controls.Primitives.LoopingSelector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLoopingSelectorPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.LoopingSelectorPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLoopingSelectorPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.LoopingSelectorPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxOrientedVirtualizingPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxOrientedVirtualizingPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPivotPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.PivotPanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPivotPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.PivotPanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPopupEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.Popup _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPopupEvents(global::Windows.UI.Xaml.Controls.Primitives.Popup data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Closed += x, x => _data.Closed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRangeBaseEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.RangeBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRangeBaseEvents(global::Windows.UI.Xaml.Controls.Primitives.RangeBase data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxScrollBarEvents : global::Windows.UI.Xaml.Controls.Primitives.RxRangeBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.ScrollBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxScrollBarEvents(global::Windows.UI.Xaml.Controls.Primitives.ScrollBar data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scroll += x, x => _data.Scroll -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSelectorEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.Selector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSelectorEvents(global::Windows.UI.Xaml.Controls.Primitives.Selector data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxThumbEvents : global::Windows.UI.Xaml.Controls.RxControlEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.Thumb _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxThumbEvents(global::Windows.UI.Xaml.Controls.Primitives.Thumb data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxToggleButtonEvents : global::Windows.UI.Xaml.Controls.Primitives.RxButtonBaseEvents + { + private readonly global::Windows.UI.Xaml.Controls.Primitives.ToggleButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxToggleButtonEvents(global::Windows.UI.Xaml.Controls.Primitives.ToggleButton data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Checked += x, x => _data.Checked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); + } +} + +namespace Windows.UI.Xaml.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::Windows.UI.Xaml.Data.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::Windows.UI.Xaml.Data.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::Windows.UI.Xaml.Data.ICollectionView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Data.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + } +} + +namespace Windows.UI.Xaml.Documents +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxContentLinkEvents Events(this global::Windows.UI.Xaml.Documents.ContentLink item) => new RxContentLinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHyperlinkEvents Events(this global::Windows.UI.Xaml.Documents.Hyperlink item) => new RxHyperlinkEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTextElementEvents Events(this global::Windows.UI.Xaml.Documents.TextElement item) => new RxTextElementEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxContentLinkEvents : global::Windows.UI.Xaml.Documents.RxTextElementEvents + { + private readonly global::Windows.UI.Xaml.Documents.ContentLink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxContentLinkEvents(global::Windows.UI.Xaml.Documents.ContentLink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Invoked += x, x => _data.Invoked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHyperlinkEvents : global::Windows.UI.Xaml.Documents.RxTextElementEvents + { + private readonly global::Windows.UI.Xaml.Documents.Hyperlink _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHyperlinkEvents(global::Windows.UI.Xaml.Documents.Hyperlink data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args)> Click => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Click += x, x => _data.Click -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTextElementEvents + { + private readonly global::Windows.UI.Xaml.Documents.TextElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTextElementEvents(global::Windows.UI.Xaml.Documents.TextElement data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)> AccessKeyDisplayDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)> AccessKeyDisplayRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)> AccessKeyInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + } +} + +namespace Windows.UI.Xaml.Hosting +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDesignerAppManagerEvents Events(this global::Windows.UI.Xaml.Hosting.DesignerAppManager item) => new RxDesignerAppManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDesktopWindowXamlSourceEvents Events(this global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource item) => new RxDesktopWindowXamlSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDesignerAppManagerEvents + { + private readonly global::Windows.UI.Xaml.Hosting.DesignerAppManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDesignerAppManagerEvents(global::Windows.UI.Xaml.Hosting.DesignerAppManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Hosting.DesignerAppManager sender, global::Windows.UI.Xaml.Hosting.DesignerAppExitedEventArgs args)> DesignerAppExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Hosting.DesignerAppManager sender, global::Windows.UI.Xaml.Hosting.DesignerAppExitedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Hosting.DesignerAppManager sender, global::Windows.UI.Xaml.Hosting.DesignerAppExitedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DesignerAppExited += x, x => _data.DesignerAppExited -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDesktopWindowXamlSourceEvents + { + private readonly global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDesktopWindowXamlSourceEvents(global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceGotFocusEventArgs args)> GotFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceGotFocusEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceGotFocusEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceTakeFocusRequestedEventArgs args)> TakeFocusRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceTakeFocusRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSource sender, global::Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceTakeFocusRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.TakeFocusRequested += x, x => _data.TakeFocusRequested -= x); + } +} + +namespace Windows.UI.Xaml.Input +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxKeyboardAcceleratorEvents Events(this global::Windows.UI.Xaml.Input.KeyboardAccelerator item) => new RxKeyboardAcceleratorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlUICommandEvents Events(this global::Windows.UI.Xaml.Input.XamlUICommand item) => new RxXamlUICommandEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxKeyboardAcceleratorEvents + { + private readonly global::Windows.UI.Xaml.Input.KeyboardAccelerator _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxKeyboardAcceleratorEvents(global::Windows.UI.Xaml.Input.KeyboardAccelerator data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Invoked += x, x => _data.Invoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlUICommandEvents + { + private readonly global::Windows.UI.Xaml.Input.XamlUICommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlUICommandEvents(global::Windows.UI.Xaml.Input.XamlUICommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args)> CanExecuteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CanExecuteRequested += x, x => _data.CanExecuteRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args)> ExecuteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ExecuteRequested += x, x => _data.ExecuteRequested -= x); + } +} + +namespace Windows.UI.Xaml.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIBindableObservableVectorEvents Events(this global::Windows.UI.Xaml.Interop.IBindableObservableVector item) => new RxIBindableObservableVectorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIBindableObservableVectorEvents + { + private readonly global::Windows.UI.Xaml.Interop.IBindableObservableVector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIBindableObservableVectorEvents(global::Windows.UI.Xaml.Interop.IBindableObservableVector data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Interop.IBindableObservableVector vector, object e)> VectorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Interop.IBindableObservableVector vector, object e) => eventHandler((vector, e)); + return Handler; + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + } +} + +namespace Windows.UI.Xaml.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageBrushEvents Events(this global::Windows.UI.Xaml.Media.ImageBrush item) => new RxImageBrushEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLoadedImageSurfaceEvents Events(this global::Windows.UI.Xaml.Media.LoadedImageSurface item) => new RxLoadedImageSurfaceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxImageBrushEvents + { + private readonly global::Windows.UI.Xaml.Media.ImageBrush _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxImageBrushEvents(global::Windows.UI.Xaml.Media.ImageBrush data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxLoadedImageSurfaceEvents + { + private readonly global::Windows.UI.Xaml.Media.LoadedImageSurface _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxLoadedImageSurfaceEvents(global::Windows.UI.Xaml.Media.LoadedImageSurface data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args)> LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + } +} + +namespace Windows.UI.Xaml.Media.Animation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxConnectedAnimationEvents Events(this global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation item) => new RxConnectedAnimationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineEvents Events(this global::Windows.UI.Xaml.Media.Animation.Timeline item) => new RxTimelineEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxConnectedAnimationEvents + { + private readonly global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxConnectedAnimationEvents(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxTimelineEvents + { + private readonly global::Windows.UI.Xaml.Media.Animation.Timeline _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxTimelineEvents(global::Windows.UI.Xaml.Media.Animation.Timeline data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } +} + +namespace Windows.UI.Xaml.Media.Imaging +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBitmapImageEvents Events(this global::Windows.UI.Xaml.Media.Imaging.BitmapImage item) => new RxBitmapImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSvgImageSourceEvents Events(this global::Windows.UI.Xaml.Media.Imaging.SvgImageSource item) => new RxSvgImageSourceEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBitmapImageEvents + { + private readonly global::Windows.UI.Xaml.Media.Imaging.BitmapImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBitmapImageEvents(global::Windows.UI.Xaml.Media.Imaging.BitmapImage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ImageOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSvgImageSourceEvents + { + private readonly global::Windows.UI.Xaml.Media.Imaging.SvgImageSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSvgImageSourceEvents(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Opened += x, x => _data.Opened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args)> OpenFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + } +} + +namespace Windows.UI.Xaml.Printing +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPrintDocumentEvents Events(this global::Windows.UI.Xaml.Printing.PrintDocument item) => new RxPrintDocumentEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPrintDocumentEvents + { + private readonly global::Windows.UI.Xaml.Printing.PrintDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPrintDocumentEvents(global::Windows.UI.Xaml.Printing.PrintDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddPages => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Printing.AddPagesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddPages += x, x => _data.AddPages -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable GetPreviewPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Printing.GetPreviewPageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.GetPreviewPage += x, x => _data.GetPreviewPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Paginate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Printing.PaginateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Paginate += x, x => _data.Paginate -= x); + } +} + +namespace Windows.Web.Http.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHttpDiagnosticProviderEvents Events(this global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider item) => new RxHttpDiagnosticProviderEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHttpDiagnosticProviderEvents + { + private readonly global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHttpDiagnosticProviderEvents(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestResponseCompletedEventArgs args)> RequestResponseCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestResponseCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestResponseCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RequestResponseCompleted += x, x => _data.RequestResponseCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestSentEventArgs args)> RequestSent => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestSentEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestSentEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.RequestSent += x, x => _data.RequestSent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderResponseReceivedEventArgs args)> ResponseReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderResponseReceivedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.Http.Diagnostics.HttpDiagnosticProvider sender, global::Windows.Web.Http.Diagnostics.HttpDiagnosticProviderResponseReceivedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ResponseReceived += x, x => _data.ResponseReceived -= x); + } +} + +namespace Windows.Web.Http.Filters +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHttpBaseProtocolFilterEvents Events(this global::Windows.Web.Http.Filters.HttpBaseProtocolFilter item) => new RxHttpBaseProtocolFilterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHttpBaseProtocolFilterEvents + { + private readonly global::Windows.Web.Http.Filters.HttpBaseProtocolFilter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHttpBaseProtocolFilterEvents(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args)> ServerCustomValidationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + } +} + +namespace Windows.Web.UI +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIWebViewControlEvents Events(this global::Windows.Web.UI.IWebViewControl item) => new RxIWebViewControlEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIWebViewControlEvents + { + private readonly global::Windows.Web.UI.IWebViewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIWebViewControlEvents(global::Windows.Web.UI.IWebViewControl data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)> ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + } +} + +namespace Windows.Web.UI.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebViewControlEvents Events(this global::Windows.Web.UI.Interop.WebViewControl item) => new RxWebViewControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebViewControlProcessEvents Events(this global::Windows.Web.UI.Interop.WebViewControlProcess item) => new RxWebViewControlProcessEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebViewControlEvents + { + private readonly global::Windows.Web.UI.Interop.WebViewControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebViewControlEvents(global::Windows.Web.UI.Interop.WebViewControl data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args)> AcceleratorKeyPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.AcceleratorKeyPressed += x, x => _data.AcceleratorKeyPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, object args)> GotFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, object args)> LostFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args)> MoveFocusRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.MoveFocusRequested += x, x => _data.MoveFocusRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)> ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebViewControlProcessEvents + { + private readonly global::Windows.Web.UI.Interop.WebViewControlProcess _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebViewControlProcessEvents(global::Windows.Web.UI.Interop.WebViewControlProcess data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args)> ProcessExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args)>(eventHandler => + { + void Handler(global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ProcessExited += x, x => _data.ProcessExited -= x); + } +} + +namespace Windows.ApplicationModel.Calls +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PhoneCallManagerCallStateChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Calls.PhoneCallManager.CallStateChanged += x, x => global::Windows.ApplicationModel.Calls.PhoneCallManager.CallStateChanged -= x); + } +} + +namespace Windows.ApplicationModel.Chat +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RcsManagerTransportListChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged += x, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged -= x); + } +} + +namespace Windows.ApplicationModel.Core +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationBackgroundActivated => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated += x, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationEnteredBackground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.EnteredBackgroundEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationExiting => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationLeavingBackground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.LeavingBackgroundEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationResuming => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationSuspending => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.SuspendingEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CoreApplicationUnhandledErrorDetected => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected += x, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected -= x); + } +} + +namespace Windows.ApplicationModel.DataTransfer +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ClipboardContentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ClipboardHistoryChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.DataTransfer.ClipboardHistoryChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.DataTransfer.ClipboardHistoryChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ClipboardHistoryEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ClipboardRoamingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged -= x); + } +} + +namespace Windows.Foundation.Diagnostics +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AsyncCausalityTracerTracingStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged += x, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged -= x); + } +} + +namespace Windows.Gaming.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ArcadeStickArcadeStickAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.ArcadeStick>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ArcadeStickArcadeStickRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.ArcadeStick>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FlightStickFlightStickAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.FlightStick>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FlightStickFlightStickRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.FlightStick>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GamepadGamepadAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.Gamepad>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded += x, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GamepadGamepadRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.Gamepad>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved += x, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RacingWheelRacingWheelAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RacingWheel>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RacingWheelRacingWheelRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RacingWheel>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RawGameControllerRawGameControllerAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RawGameController>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RawGameControllerRawGameControllerRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RawGameController>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable UINavigationControllerUINavigationControllerAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.UINavigationController>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable UINavigationControllerUINavigationControllerRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.UINavigationController>(eventHandler => + { + void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved -= x); + } +} + +namespace Windows.Gaming.Preview.GamesEnumeration +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GameListGameAdded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Gaming.Preview.GamesEnumeration.GameListEntry game) => eventHandler(game); + return Handler; + }, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameAdded += x, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GameListGameRemoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(string identifier) => eventHandler(identifier); + return Handler; + }, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameRemoved += x, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GameListGameUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.Gaming.Preview.GamesEnumeration.GameListEntry game) => eventHandler(game); + return Handler; + }, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameUpdated += x, x => global::Windows.Gaming.Preview.GamesEnumeration.GameList.GameUpdated -= x); + } +} + +namespace Windows.Gaming.UI +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GameBarIsInputRedirectedChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged += x, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable GameBarVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged += x, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged -= x); + } +} + +namespace Windows.Graphics.Display +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> DisplayInformationDisplayContentsInvalidated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => + { + void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable DisplayPropertiesColorProfileChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable DisplayPropertiesDisplayContentsInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable DisplayPropertiesLogicalDpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable DisplayPropertiesOrientationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable DisplayPropertiesStereoEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged -= x); + } +} + +namespace Windows.Graphics.Holographic +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable HolographicSpaceIsAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged += x, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged -= x); + } +} + +namespace Windows.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlChannelDownPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.ChannelDownPressed += x, x => global::Windows.Media.MediaControl.ChannelDownPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlChannelUpPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.ChannelUpPressed += x, x => global::Windows.Media.MediaControl.ChannelUpPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlFastForwardPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.FastForwardPressed += x, x => global::Windows.Media.MediaControl.FastForwardPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlNextTrackPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.NextTrackPressed += x, x => global::Windows.Media.MediaControl.NextTrackPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlPausePressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.PausePressed += x, x => global::Windows.Media.MediaControl.PausePressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlPlayPauseTogglePressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.PlayPauseTogglePressed += x, x => global::Windows.Media.MediaControl.PlayPauseTogglePressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlPlayPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.PlayPressed += x, x => global::Windows.Media.MediaControl.PlayPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlPreviousTrackPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.PreviousTrackPressed += x, x => global::Windows.Media.MediaControl.PreviousTrackPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlRecordPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.RecordPressed += x, x => global::Windows.Media.MediaControl.RecordPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlRewindPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.RewindPressed += x, x => global::Windows.Media.MediaControl.RewindPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlSoundLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.SoundLevelChanged += x, x => global::Windows.Media.MediaControl.SoundLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaControlStopPressed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.MediaControl.StopPressed += x, x => global::Windows.Media.MediaControl.StopPressed -= x); + } +} + +namespace Windows.Media.Core.Preview +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SoundLevelBrokerSoundLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged += x, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged -= x); + } +} + +namespace Windows.Media.Devices +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaDeviceDefaultAudioCaptureDeviceChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Devices.DefaultAudioCaptureDeviceChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Media.Devices.DefaultAudioCaptureDeviceChangedEventArgs args) => eventHandler(args); + return Handler; + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MediaDeviceDefaultAudioRenderDeviceChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Devices.DefaultAudioRenderDeviceChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Media.Devices.DefaultAudioRenderDeviceChangedEventArgs args) => eventHandler(args); + return Handler; + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged -= x); + } +} + +namespace Windows.Media.Playback +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BackgroundMediaPlayerMessageReceivedFromBackground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BackgroundMediaPlayerMessageReceivedFromForeground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground -= x); + } +} + +namespace Windows.Networking.Connectivity +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable NetworkInformationNetworkStatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged += x, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged -= x); + } +} + +namespace Windows.Networking.NetworkOperators +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ESimManagerServiceInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged += x, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged -= x); + } +} + +namespace Windows.Networking.Proximity +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PeerFinderConnectionRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Networking.Proximity.ConnectionRequestedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Networking.Proximity.ConnectionRequestedEventArgs args) => eventHandler(args); + return Handler; + }, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested += x, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PeerFinderTriggeredConnectionStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Networking.Proximity.TriggeredConnectionStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Networking.Proximity.TriggeredConnectionStateChangedEventArgs args) => eventHandler(args); + return Handler; + }, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged += x, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged -= x); + } +} + +namespace Windows.Networking.PushNotifications +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PushNotificationChannelManagerChannelsRevoked => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Networking.PushNotifications.PushNotificationChannelsRevokedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Networking.PushNotifications.PushNotificationChannelsRevokedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Networking.PushNotifications.PushNotificationChannelManager.ChannelsRevoked += x, x => global::Windows.Networking.PushNotifications.PushNotificationChannelManager.ChannelsRevoked -= x); + } +} + +namespace Windows.Perception.Spatial +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SpatialStageFrameOfReferenceCurrentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged += x, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged -= x); + } +} + +namespace Windows.Phone.System.Power +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerPowerSavingModeChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged += x, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged -= x); + } +} + +namespace Windows.Phone.UI.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable HardwareButtonsBackPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.BackPressedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Phone.UI.Input.BackPressedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable HardwareButtonsCameraHalfPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.CameraEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable HardwareButtonsCameraPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.CameraEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable HardwareButtonsCameraReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.CameraEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased -= x); + } +} + +namespace Windows.Security.Authentication.Identity.Provider +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SecondaryAuthenticationFactorAuthenticationAuthenticationStageChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged += x, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged -= x); + } +} + +namespace Windows.Security.EnterpriseData +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ProtectionPolicyManagerPolicyChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.PolicyChanged += x, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.PolicyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ProtectionPolicyManagerProtectedAccessResumed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Security.EnterpriseData.ProtectedAccessResumedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Security.EnterpriseData.ProtectedAccessResumedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedAccessResumed += x, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedAccessResumed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ProtectionPolicyManagerProtectedAccessSuspending => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Security.EnterpriseData.ProtectedAccessSuspendingEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Security.EnterpriseData.ProtectedAccessSuspendingEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedAccessSuspending += x, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedAccessSuspending -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ProtectionPolicyManagerProtectedContentRevoked => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Security.EnterpriseData.ProtectedContentRevokedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.Security.EnterpriseData.ProtectedContentRevokedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedContentRevoked += x, x => global::Windows.Security.EnterpriseData.ProtectionPolicyManager.ProtectedContentRevoked -= x); + } +} + +namespace Windows.System +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MemoryManagerAppMemoryUsageDecreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MemoryManagerAppMemoryUsageIncreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable MemoryManagerAppMemoryUsageLimitChanging => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.System.AppMemoryUsageLimitChangingEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.System.AppMemoryUsageLimitChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging += x, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable UserDeviceAssociationUserDeviceAssociationChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.System.UserDeviceAssociationChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.System.UserDeviceAssociationChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged += x, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged -= x); + } +} + +namespace Windows.System.Power +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BackgroundEnergyManagerRecentEnergyUsageIncreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable BackgroundEnergyManagerRecentEnergyUsageReturnedToLow => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ForegroundEnergyManagerRecentEnergyUsageIncreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ForegroundEnergyManagerRecentEnergyUsageReturnedToLow => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerBatteryStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged += x, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged += x, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerPowerSupplyStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged += x, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerRemainingChargePercentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged += x, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PowerManagerRemainingDischargeTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged += x, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged -= x); + } +} + +namespace Windows.System.Profile +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable PlatformDiagnosticsAndUsageDataSettingsCollectionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged += x, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemSetupInfoOutOfBoxExperienceStateChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged += x, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WindowsIntegrityPolicyPolicyChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged += x, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged -= x); + } +} + +namespace Windows.System.Update +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable SystemUpdateManagerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.Update.SystemUpdateManager.StateChanged += x, x => global::Windows.System.Update.SystemUpdateManager.StateChanged -= x); + } +} + +namespace Windows.System.UserProfile +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable UserInformationAccountPictureChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.System.UserProfile.UserInformation.AccountPictureChanged += x, x => global::Windows.System.UserProfile.UserInformation.AccountPictureChanged -= x); + } +} + +namespace Windows.UI.ViewManagement +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable ProjectionManagerProjectionDisplayAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged += x, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged -= x); + } +} + +namespace Windows.UI.WebUI +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationActivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs eventArgs) => eventHandler(eventArgs); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.Activated += x, x => global::Windows.UI.WebUI.WebUIApplication.Activated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationBackgroundActivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs eventArgs) => eventHandler(eventArgs); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated += x, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationEnteredBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.IEnteredBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationLeavingBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.ILeavingBackgroundEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationNavigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.WebUI.IWebUINavigatedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.Navigated += x, x => global::Windows.UI.WebUI.WebUIApplication.Navigated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationNewWebUIViewCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.WebUI.NewWebUIViewCreatedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.WebUI.NewWebUIViewCreatedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated += x, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationResuming => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender) => eventHandler(sender); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.Resuming += x, x => global::Windows.UI.WebUI.WebUIApplication.Resuming -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable WebUIApplicationSuspending => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.ApplicationModel.ISuspendingEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.WebUI.WebUIApplication.Suspending += x, x => global::Windows.UI.WebUI.WebUIApplication.Suspending -= x); + } +} + +namespace Windows.UI.Xaml.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AccessKeyManagerIsDisplayModeEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object args) => eventHandler(args); + return Handler; + }, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged += x, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerGettingFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.GettingFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerGotFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.FocusManagerGotFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerGotFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerLosingFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.LosingFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerLostFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.FocusManagerLostFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerLostFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus -= x); + } +} + +namespace Windows.UI.Xaml.Media +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Media.RenderedEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Media.RenderedEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable CompositionTargetSurfaceContentsLost => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/xamarin.ios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/xamarin.ios10.approved.txt new file mode 100644 index 0000000..d694903 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/xamarin.ios10.approved.txt @@ -0,0 +1,14786 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace AddressBook +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxABAddressBookEvents Events(this global::AddressBook.ABAddressBook item) => new RxABAddressBookEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxABAddressBookEvents + { + private readonly global::AddressBook.ABAddressBook _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxABAddressBookEvents(global::AddressBook.ABAddressBook data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ExternalChange => global::System.Reactive.Linq.Observable.FromEvent, global::AddressBook.ExternalChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::AddressBook.ExternalChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ExternalChange += x, x => _data.ExternalChange -= x); + } +} + +namespace AddressBookUI +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxABNewPersonViewControllerEvents Events(this global::AddressBookUI.ABNewPersonViewController item) => new RxABNewPersonViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxABPeoplePickerNavigationControllerEvents Events(this global::AddressBookUI.ABPeoplePickerNavigationController item) => new RxABPeoplePickerNavigationControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxABPersonViewControllerEvents Events(this global::AddressBookUI.ABPersonViewController item) => new RxABPersonViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxABUnknownPersonViewControllerEvents Events(this global::AddressBookUI.ABUnknownPersonViewController item) => new RxABUnknownPersonViewControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxABNewPersonViewControllerEvents + { + private readonly global::AddressBookUI.ABNewPersonViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxABNewPersonViewControllerEvents(global::AddressBookUI.ABNewPersonViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NewPersonComplete => global::System.Reactive.Linq.Observable.FromEvent, global::AddressBookUI.ABNewPersonCompleteEventArgs>(eventHandler => + { + void Handler(object sender, global::AddressBookUI.ABNewPersonCompleteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NewPersonComplete += x, x => _data.NewPersonComplete -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxABPeoplePickerNavigationControllerEvents + { + private readonly global::AddressBookUI.ABPeoplePickerNavigationController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxABPeoplePickerNavigationControllerEvents(global::AddressBookUI.ABPeoplePickerNavigationController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Cancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Cancelled += x, x => _data.Cancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PerformAction => global::System.Reactive.Linq.Observable.FromEvent, global::AddressBookUI.ABPeoplePickerPerformActionEventArgs>(eventHandler => + { + void Handler(object sender, global::AddressBookUI.ABPeoplePickerPerformActionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PerformAction += x, x => _data.PerformAction -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PerformAction2 => global::System.Reactive.Linq.Observable.FromEvent, global::AddressBookUI.ABPeoplePickerPerformAction2EventArgs>(eventHandler => + { + void Handler(object sender, global::AddressBookUI.ABPeoplePickerPerformAction2EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PerformAction2 += x, x => _data.PerformAction2 -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectPerson => global::System.Reactive.Linq.Observable.FromEvent, global::AddressBookUI.ABPeoplePickerSelectPersonEventArgs>(eventHandler => + { + void Handler(object sender, global::AddressBookUI.ABPeoplePickerSelectPersonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectPerson += x, x => _data.SelectPerson -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectPerson2 => global::System.Reactive.Linq.Observable.FromEvent, global::AddressBookUI.ABPeoplePickerSelectPerson2EventArgs>(eventHandler => + { + void Handler(object sender, global::AddressBookUI.ABPeoplePickerSelectPerson2EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectPerson2 += x, x => _data.SelectPerson2 -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxABPersonViewControllerEvents + { + private readonly global::AddressBookUI.ABPersonViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxABPersonViewControllerEvents(global::AddressBookUI.ABPersonViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PerformDefaultAction => global::System.Reactive.Linq.Observable.FromEvent, global::AddressBookUI.ABPersonViewPerformDefaultActionEventArgs>(eventHandler => + { + void Handler(object sender, global::AddressBookUI.ABPersonViewPerformDefaultActionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PerformDefaultAction += x, x => _data.PerformDefaultAction -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxABUnknownPersonViewControllerEvents + { + private readonly global::AddressBookUI.ABUnknownPersonViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxABUnknownPersonViewControllerEvents(global::AddressBookUI.ABUnknownPersonViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PerformDefaultAction => global::System.Reactive.Linq.Observable.FromEvent, global::AddressBookUI.ABPersonViewPerformDefaultActionEventArgs>(eventHandler => + { + void Handler(object sender, global::AddressBookUI.ABPersonViewPerformDefaultActionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PerformDefaultAction += x, x => _data.PerformDefaultAction -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PersonCreated => global::System.Reactive.Linq.Observable.FromEvent, global::AddressBookUI.ABUnknownPersonCreatedEventArgs>(eventHandler => + { + void Handler(object sender, global::AddressBookUI.ABUnknownPersonCreatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PersonCreated += x, x => _data.PersonCreated -= x); + } +} + +namespace AudioToolbox +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputAudioQueueEvents Events(this global::AudioToolbox.InputAudioQueue item) => new RxInputAudioQueueEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxOutputAudioQueueEvents Events(this global::AudioToolbox.OutputAudioQueue item) => new RxOutputAudioQueueEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputAudioQueueEvents + { + private readonly global::AudioToolbox.InputAudioQueue _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputAudioQueueEvents(global::AudioToolbox.InputAudioQueue data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::AudioToolbox.InputCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::AudioToolbox.InputCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputCompleted += x, x => _data.InputCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxOutputAudioQueueEvents + { + private readonly global::AudioToolbox.OutputAudioQueue _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxOutputAudioQueueEvents(global::AudioToolbox.OutputAudioQueue data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::AudioToolbox.BufferCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::AudioToolbox.BufferCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferCompleted += x, x => _data.BufferCompleted -= x); + } +} + +namespace AVFoundation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAVAudioPlayerEvents Events(this global::AVFoundation.AVAudioPlayer item) => new RxAVAudioPlayerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAVAudioRecorderEvents Events(this global::AVFoundation.AVAudioRecorder item) => new RxAVAudioRecorderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAVAudioSessionEvents Events(this global::AVFoundation.AVAudioSession item) => new RxAVAudioSessionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAVSpeechSynthesizerEvents Events(this global::AVFoundation.AVSpeechSynthesizer item) => new RxAVSpeechSynthesizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAVAudioPlayerEvents + { + private readonly global::AVFoundation.AVAudioPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAVAudioPlayerEvents(global::AVFoundation.AVAudioPlayer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginInterruption => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginInterruption += x, x => _data.BeginInterruption -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecoderError => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecoderError += x, x => _data.DecoderError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndInterruption => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndInterruption += x, x => _data.EndInterruption -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FinishedPlaying => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVStatusEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVStatusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FinishedPlaying += x, x => _data.FinishedPlaying -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAVAudioRecorderEvents + { + private readonly global::AVFoundation.AVAudioRecorder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAVAudioRecorderEvents(global::AVFoundation.AVAudioRecorder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginInterruption => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginInterruption += x, x => _data.BeginInterruption -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncoderError => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncoderError += x, x => _data.EncoderError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndInterruption => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndInterruption += x, x => _data.EndInterruption -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FinishedRecording => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVStatusEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVStatusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FinishedRecording += x, x => _data.FinishedRecording -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAVAudioSessionEvents + { + private readonly global::AVFoundation.AVAudioSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAVAudioSessionEvents(global::AVFoundation.AVAudioSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginInterruption => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginInterruption += x, x => _data.BeginInterruption -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CategoryChanged => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVCategoryEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVCategoryEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CategoryChanged += x, x => _data.CategoryChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndInterruption => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndInterruption += x, x => _data.EndInterruption -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputAvailabilityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVStatusEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVStatusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputAvailabilityChanged += x, x => _data.InputAvailabilityChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputChannelsChanged => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVChannelsEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVChannelsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputChannelsChanged += x, x => _data.InputChannelsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OutputChannelsChanged => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVChannelsEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVChannelsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OutputChannelsChanged += x, x => _data.OutputChannelsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SampleRateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSampleRateEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSampleRateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SampleRateChanged += x, x => _data.SampleRateChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAVSpeechSynthesizerEvents + { + private readonly global::AVFoundation.AVSpeechSynthesizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAVSpeechSynthesizerEvents(global::AVFoundation.AVSpeechSynthesizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidCancelSpeechUtterance => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidCancelSpeechUtterance += x, x => _data.DidCancelSpeechUtterance -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidContinueSpeechUtterance => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidContinueSpeechUtterance += x, x => _data.DidContinueSpeechUtterance -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinishSpeechUtterance => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinishSpeechUtterance += x, x => _data.DidFinishSpeechUtterance -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidPauseSpeechUtterance => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidPauseSpeechUtterance += x, x => _data.DidPauseSpeechUtterance -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidStartSpeechUtterance => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidStartSpeechUtterance += x, x => _data.DidStartSpeechUtterance -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillSpeakRangeOfSpeechString => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerWillSpeakEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerWillSpeakEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillSpeakRangeOfSpeechString += x, x => _data.WillSpeakRangeOfSpeechString -= x); + } +} + +namespace CoreAnimation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCAAnimationEvents Events(this global::CoreAnimation.CAAnimation item) => new RxCAAnimationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCAAnimationEvents + { + private readonly global::CoreAnimation.CAAnimation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCAAnimationEvents(global::CoreAnimation.CAAnimation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnimationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnimationStarted += x, x => _data.AnimationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnimationStopped => global::System.Reactive.Linq.Observable.FromEvent, global::CoreAnimation.CAAnimationStateEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreAnimation.CAAnimationStateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnimationStopped += x, x => _data.AnimationStopped -= x); + } +} + +namespace CoreBluetooth +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCBCentralManagerEvents Events(this global::CoreBluetooth.CBCentralManager item) => new RxCBCentralManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCBPeripheralEvents Events(this global::CoreBluetooth.CBPeripheral item) => new RxCBPeripheralEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCBPeripheralManagerEvents Events(this global::CoreBluetooth.CBPeripheralManager item) => new RxCBPeripheralManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCBCentralManagerEvents + { + private readonly global::CoreBluetooth.CBCentralManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCBCentralManagerEvents(global::CoreBluetooth.CBCentralManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ConnectedPeripheral => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ConnectedPeripheral += x, x => _data.ConnectedPeripheral -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ConnectionEventDidOccur => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralConnectionEventEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralConnectionEventEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ConnectionEventDidOccur += x, x => _data.ConnectionEventDidOccur -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateAncsAuthorization => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBAncsAuthorizationUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBAncsAuthorizationUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateAncsAuthorization += x, x => _data.DidUpdateAncsAuthorization -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisconnectedPeripheral => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisconnectedPeripheral += x, x => _data.DisconnectedPeripheral -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DiscoveredPeripheral => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBDiscoveredPeripheralEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBDiscoveredPeripheralEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DiscoveredPeripheral += x, x => _data.DiscoveredPeripheral -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FailedToConnectPeripheral => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FailedToConnectPeripheral += x, x => _data.FailedToConnectPeripheral -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrievedConnectedPeripherals => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralsEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrievedConnectedPeripherals += x, x => _data.RetrievedConnectedPeripherals -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrievedPeripherals => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralsEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrievedPeripherals += x, x => _data.RetrievedPeripherals -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedState => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedState += x, x => _data.UpdatedState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillRestoreState => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBWillRestoreEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBWillRestoreEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillRestoreState += x, x => _data.WillRestoreState -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCBPeripheralEvents + { + private readonly global::CoreBluetooth.CBPeripheral _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCBPeripheralEvents(global::CoreBluetooth.CBPeripheral data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidOpenL2CapChannel => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralOpenL2CapChannelEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralOpenL2CapChannelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidOpenL2CapChannel += x, x => _data.DidOpenL2CapChannel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DiscoveredCharacteristic => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBServiceEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBServiceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DiscoveredCharacteristic += x, x => _data.DiscoveredCharacteristic -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DiscoveredDescriptor => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBCharacteristicEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBCharacteristicEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DiscoveredDescriptor += x, x => _data.DiscoveredDescriptor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DiscoveredIncludedService => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBServiceEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBServiceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DiscoveredIncludedService += x, x => _data.DiscoveredIncludedService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DiscoveredService => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DiscoveredService += x, x => _data.DiscoveredService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidatedService => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidatedService += x, x => _data.InvalidatedService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsReadyToSendWriteWithoutResponse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsReadyToSendWriteWithoutResponse += x, x => _data.IsReadyToSendWriteWithoutResponse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedServices => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralServicesEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralServicesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedServices += x, x => _data.ModifiedServices -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RssiRead => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBRssiEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBRssiEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RssiRead += x, x => _data.RssiRead -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RssiUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RssiUpdated += x, x => _data.RssiUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedCharacterteristicValue => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBCharacteristicEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBCharacteristicEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedCharacterteristicValue += x, x => _data.UpdatedCharacterteristicValue -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedName => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedName += x, x => _data.UpdatedName -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedNotificationState => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBCharacteristicEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBCharacteristicEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedNotificationState += x, x => _data.UpdatedNotificationState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedValue => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBDescriptorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBDescriptorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedValue += x, x => _data.UpdatedValue -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WroteCharacteristicValue => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBCharacteristicEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBCharacteristicEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WroteCharacteristicValue += x, x => _data.WroteCharacteristicValue -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WroteDescriptorValue => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBDescriptorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBDescriptorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WroteDescriptorValue += x, x => _data.WroteDescriptorValue -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCBPeripheralManagerEvents + { + private readonly global::CoreBluetooth.CBPeripheralManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCBPeripheralManagerEvents(global::CoreBluetooth.CBPeripheralManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AdvertisingStarted => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AdvertisingStarted += x, x => _data.AdvertisingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CharacteristicSubscribed => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerSubscriptionEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerSubscriptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CharacteristicSubscribed += x, x => _data.CharacteristicSubscribed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CharacteristicUnsubscribed => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerSubscriptionEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerSubscriptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CharacteristicUnsubscribed += x, x => _data.CharacteristicUnsubscribed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidOpenL2CapChannel => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerOpenL2CapChannelEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerOpenL2CapChannelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidOpenL2CapChannel += x, x => _data.DidOpenL2CapChannel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidPublishL2CapChannel => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerL2CapChannelOperationEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerL2CapChannelOperationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidPublishL2CapChannel += x, x => _data.DidPublishL2CapChannel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUnpublishL2CapChannel => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerL2CapChannelOperationEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerL2CapChannelOperationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUnpublishL2CapChannel += x, x => _data.DidUnpublishL2CapChannel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadRequestReceived => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBATTRequestEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBATTRequestEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadRequestReceived += x, x => _data.ReadRequestReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadyToUpdateSubscribers => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadyToUpdateSubscribers += x, x => _data.ReadyToUpdateSubscribers -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ServiceAdded => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerServiceEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerServiceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ServiceAdded += x, x => _data.ServiceAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateUpdated += x, x => _data.StateUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillRestoreState => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBWillRestoreEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBWillRestoreEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillRestoreState += x, x => _data.WillRestoreState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WriteRequestsReceived => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBATTRequestsEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBATTRequestsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WriteRequestsReceived += x, x => _data.WriteRequestsReceived -= x); + } +} + +namespace CoreFoundation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCFSocketEvents Events(this global::CoreFoundation.CFSocket item) => new RxCFSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCFStreamEvents Events(this global::CoreFoundation.CFStream item) => new RxCFStreamEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCFSocketEvents + { + private readonly global::CoreFoundation.CFSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCFSocketEvents(global::CoreFoundation.CFSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFSocket.CFSocketAcceptEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFSocket.CFSocketAcceptEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptEvent += x, x => _data.AcceptEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ConnectEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFSocket.CFSocketConnectEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFSocket.CFSocketConnectEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ConnectEvent += x, x => _data.ConnectEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFSocket.CFSocketDataEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFSocket.CFSocketDataEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataEvent += x, x => _data.DataEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFSocket.CFSocketReadEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFSocket.CFSocketReadEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadEvent += x, x => _data.ReadEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WriteEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFSocket.CFSocketWriteEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFSocket.CFSocketWriteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WriteEvent += x, x => _data.WriteEvent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCFStreamEvents + { + private readonly global::CoreFoundation.CFStream _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCFStreamEvents(global::CoreFoundation.CFStream data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanAcceptBytesEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFStream.StreamEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFStream.StreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanAcceptBytesEvent += x, x => _data.CanAcceptBytesEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClosedEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFStream.StreamEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFStream.StreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClosedEvent += x, x => _data.ClosedEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFStream.StreamEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFStream.StreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorEvent += x, x => _data.ErrorEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HasBytesAvailableEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFStream.StreamEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFStream.StreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HasBytesAvailableEvent += x, x => _data.HasBytesAvailableEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OpenCompletedEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFStream.StreamEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFStream.StreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OpenCompletedEvent += x, x => _data.OpenCompletedEvent -= x); + } +} + +namespace CoreLocation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCLLocationManagerEvents Events(this global::CoreLocation.CLLocationManager item) => new RxCLLocationManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCLLocationManagerEvents + { + private readonly global::CoreLocation.CLLocationManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCLLocationManagerEvents(global::CoreLocation.CLLocationManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorizationChanged => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLAuthorizationChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLAuthorizationChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorizationChanged += x, x => _data.AuthorizationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DeferredUpdatesFinished => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DeferredUpdatesFinished += x, x => _data.DeferredUpdatesFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidChangeAuthorization => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidChangeAuthorization += x, x => _data.DidChangeAuthorization -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDetermineState => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionStateDeterminedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionStateDeterminedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDetermineState += x, x => _data.DidDetermineState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFailRangingBeacons => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionBeaconsConstraintFailedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionBeaconsConstraintFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFailRangingBeacons += x, x => _data.DidFailRangingBeacons -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRangeBeacons => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionBeaconsRangedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionBeaconsRangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRangeBeacons += x, x => _data.DidRangeBeacons -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRangeBeaconsSatisfyingConstraint => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionBeaconsConstraintRangedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionBeaconsConstraintRangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRangeBeaconsSatisfyingConstraint += x, x => _data.DidRangeBeaconsSatisfyingConstraint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidStartMonitoringForRegion => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidStartMonitoringForRegion += x, x => _data.DidStartMonitoringForRegion -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidVisit => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLVisitedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLVisitedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidVisit += x, x => _data.DidVisit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Failed => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationsUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLLocationsUpdatedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLLocationsUpdatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationsUpdated += x, x => _data.LocationsUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationUpdatesPaused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationUpdatesPaused += x, x => _data.LocationUpdatesPaused -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationUpdatesResumed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationUpdatesResumed += x, x => _data.LocationUpdatesResumed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MonitoringFailed => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MonitoringFailed += x, x => _data.MonitoringFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RangingBeaconsDidFailForRegion => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionBeaconsFailedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionBeaconsFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RangingBeaconsDidFailForRegion += x, x => _data.RangingBeaconsDidFailForRegion -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionEntered => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionEntered += x, x => _data.RegionEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionLeft => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionLeft += x, x => _data.RegionLeft -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedHeading => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLHeadingUpdatedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLHeadingUpdatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedHeading += x, x => _data.UpdatedHeading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedLocation => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLLocationUpdatedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLLocationUpdatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedLocation += x, x => _data.UpdatedLocation -= x); + } +} + +namespace CoreMidi +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMidiClientEvents Events(this global::CoreMidi.MidiClient item) => new RxMidiClientEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMidiEndpointEvents Events(this global::CoreMidi.MidiEndpoint item) => new RxMidiEndpointEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMidiPortEvents Events(this global::CoreMidi.MidiPort item) => new RxMidiPortEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMidiClientEvents + { + private readonly global::CoreMidi.MidiClient _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMidiClientEvents(global::CoreMidi.MidiClient data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IOError => global::System.Reactive.Linq.Observable.FromEvent, global::CoreMidi.IOErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreMidi.IOErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IOError += x, x => _data.IOError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ObjectAdded => global::System.Reactive.Linq.Observable.FromEvent, global::CoreMidi.ObjectAddedOrRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreMidi.ObjectAddedOrRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ObjectAdded += x, x => _data.ObjectAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ObjectRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::CoreMidi.ObjectAddedOrRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreMidi.ObjectAddedOrRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ObjectRemoved += x, x => _data.ObjectRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::CoreMidi.ObjectPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreMidi.ObjectPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SerialPortOwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SerialPortOwnerChanged += x, x => _data.SerialPortOwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SetupChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SetupChanged += x, x => _data.SetupChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThruConnectionsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThruConnectionsChanged += x, x => _data.ThruConnectionsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMidiEndpointEvents + { + private readonly global::CoreMidi.MidiEndpoint _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMidiEndpointEvents(global::CoreMidi.MidiEndpoint data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, global::CoreMidi.MidiPacketsEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreMidi.MidiPacketsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMidiPortEvents + { + private readonly global::CoreMidi.MidiPort _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMidiPortEvents(global::CoreMidi.MidiPort data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, global::CoreMidi.MidiPacketsEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreMidi.MidiPacketsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } +} + +namespace EventKitUI +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEKCalendarChooserEvents Events(this global::EventKitUI.EKCalendarChooser item) => new RxEKCalendarChooserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEKEventEditViewControllerEvents Events(this global::EventKitUI.EKEventEditViewController item) => new RxEKEventEditViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEKEventViewControllerEvents Events(this global::EventKitUI.EKEventViewController item) => new RxEKEventViewControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEKCalendarChooserEvents + { + private readonly global::EventKitUI.EKCalendarChooser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEKCalendarChooserEvents(global::EventKitUI.EKCalendarChooser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Cancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Cancelled += x, x => _data.Cancelled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finished += x, x => _data.Finished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEKEventEditViewControllerEvents + { + private readonly global::EventKitUI.EKEventEditViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEKEventEditViewControllerEvents(global::EventKitUI.EKEventEditViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent, global::EventKitUI.EKEventEditEventArgs>(eventHandler => + { + void Handler(object sender, global::EventKitUI.EKEventEditEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEKEventViewControllerEvents + { + private readonly global::EventKitUI.EKEventViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEKEventViewControllerEvents(global::EventKitUI.EKEventViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent, global::EventKitUI.EKEventViewEventArgs>(eventHandler => + { + void Handler(object sender, global::EventKitUI.EKEventViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } +} + +namespace ExternalAccessory +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEAAccessoryEvents Events(this global::ExternalAccessory.EAAccessory item) => new RxEAAccessoryEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEAWiFiUnconfiguredAccessoryBrowserEvents Events(this global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser item) => new RxEAWiFiUnconfiguredAccessoryBrowserEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEAAccessoryEvents + { + private readonly global::ExternalAccessory.EAAccessory _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEAAccessoryEvents(global::ExternalAccessory.EAAccessory data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disconnected += x, x => _data.Disconnected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEAWiFiUnconfiguredAccessoryBrowserEvents + { + private readonly global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEAWiFiUnconfiguredAccessoryBrowserEvents(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFindUnconfiguredAccessories => global::System.Reactive.Linq.Observable.FromEvent, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowserEventArgs>(eventHandler => + { + void Handler(object sender, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowserEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFindUnconfiguredAccessories += x, x => _data.DidFindUnconfiguredAccessories -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinishConfiguringAccessory => global::System.Reactive.Linq.Observable.FromEvent, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryDidFinishEventArgs>(eventHandler => + { + void Handler(object sender, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryDidFinishEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinishConfiguringAccessory += x, x => _data.DidFinishConfiguringAccessory -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveUnconfiguredAccessories => global::System.Reactive.Linq.Observable.FromEvent, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowserEventArgs>(eventHandler => + { + void Handler(object sender, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowserEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveUnconfiguredAccessories += x, x => _data.DidRemoveUnconfiguredAccessories -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateState => global::System.Reactive.Linq.Observable.FromEvent, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryEventArgs>(eventHandler => + { + void Handler(object sender, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateState += x, x => _data.DidUpdateState -= x); + } +} + +namespace Foundation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSCacheEvents Events(this global::Foundation.NSCache item) => new RxNSCacheEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSKeyedArchiverEvents Events(this global::Foundation.NSKeyedArchiver item) => new RxNSKeyedArchiverEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSKeyedUnarchiverEvents Events(this global::Foundation.NSKeyedUnarchiver item) => new RxNSKeyedUnarchiverEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSNetServiceEvents Events(this global::Foundation.NSNetService item) => new RxNSNetServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSNetServiceBrowserEvents Events(this global::Foundation.NSNetServiceBrowser item) => new RxNSNetServiceBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSStreamEvents Events(this global::Foundation.NSStream item) => new RxNSStreamEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSCacheEvents + { + private readonly global::Foundation.NSCache _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSCacheEvents(global::Foundation.NSCache data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillEvictObject => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSObjectEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSObjectEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillEvictObject += x, x => _data.WillEvictObject -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSKeyedArchiverEvents + { + private readonly global::Foundation.NSKeyedArchiver _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSKeyedArchiverEvents(global::Foundation.NSKeyedArchiver data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncodedObject => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSObjectEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSObjectEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncodedObject += x, x => _data.EncodedObject -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finished += x, x => _data.Finished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finishing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finishing += x, x => _data.Finishing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReplacingObject => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSArchiveReplaceEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSArchiveReplaceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReplacingObject += x, x => _data.ReplacingObject -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSKeyedUnarchiverEvents + { + private readonly global::Foundation.NSKeyedUnarchiver _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSKeyedUnarchiverEvents(global::Foundation.NSKeyedUnarchiver data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finished += x, x => _data.Finished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finishing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finishing += x, x => _data.Finishing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReplacingObject => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSArchiveReplaceEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSArchiveReplaceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReplacingObject += x, x => _data.ReplacingObject -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSNetServiceEvents + { + private readonly global::Foundation.NSNetService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSNetServiceEvents(global::Foundation.NSNetService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddressResolved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddressResolved += x, x => _data.AddressResolved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAcceptConnection => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetServiceConnectionEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetServiceConnectionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAcceptConnection += x, x => _data.DidAcceptConnection -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Published => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Published += x, x => _data.Published -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PublishFailure => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetServiceErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetServiceErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PublishFailure += x, x => _data.PublishFailure -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResolveFailure => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetServiceErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetServiceErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResolveFailure += x, x => _data.ResolveFailure -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedTxtRecordData => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetServiceDataEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetServiceDataEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedTxtRecordData += x, x => _data.UpdatedTxtRecordData -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillPublish => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillPublish += x, x => _data.WillPublish -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillResolve => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillResolve += x, x => _data.WillResolve -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSNetServiceBrowserEvents + { + private readonly global::Foundation.NSNetServiceBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSNetServiceBrowserEvents(global::Foundation.NSNetServiceBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DomainRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetDomainEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetDomainEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DomainRemoved += x, x => _data.DomainRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FoundDomain => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetDomainEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetDomainEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FoundDomain += x, x => _data.FoundDomain -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FoundService => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetServiceEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetServiceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FoundService += x, x => _data.FoundService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NotSearched => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetServiceErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetServiceErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NotSearched += x, x => _data.NotSearched -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchStarted += x, x => _data.SearchStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchStopped += x, x => _data.SearchStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ServiceRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetServiceEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetServiceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ServiceRemoved += x, x => _data.ServiceRemoved -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSStreamEvents + { + private readonly global::Foundation.NSStream _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSStreamEvents(global::Foundation.NSStream data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OnEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSStreamEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSStreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OnEvent += x, x => _data.OnEvent -= x); + } +} + +namespace GameKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGKAchievementViewControllerEvents Events(this global::GameKit.GKAchievementViewController item) => new RxGKAchievementViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGKChallengeEventHandlerEvents Events(this global::GameKit.GKChallengeEventHandler item) => new RxGKChallengeEventHandlerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGKFriendRequestComposeViewControllerEvents Events(this global::GameKit.GKFriendRequestComposeViewController item) => new RxGKFriendRequestComposeViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGKGameCenterViewControllerEvents Events(this global::GameKit.GKGameCenterViewController item) => new RxGKGameCenterViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGKLeaderboardViewControllerEvents Events(this global::GameKit.GKLeaderboardViewController item) => new RxGKLeaderboardViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGKMatchEvents Events(this global::GameKit.GKMatch item) => new RxGKMatchEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGKMatchmakerViewControllerEvents Events(this global::GameKit.GKMatchmakerViewController item) => new RxGKMatchmakerViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGKSessionEvents Events(this global::GameKit.GKSession item) => new RxGKSessionEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGKAchievementViewControllerEvents : global::GameKit.RxGKGameCenterViewControllerEvents + { + private readonly global::GameKit.GKAchievementViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGKAchievementViewControllerEvents(global::GameKit.GKAchievementViewController data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinish => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinish += x, x => _data.DidFinish -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGKChallengeEventHandlerEvents + { + private readonly global::GameKit.GKChallengeEventHandler _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGKChallengeEventHandlerEvents(global::GameKit.GKChallengeEventHandler data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocalPlayerCompletedChallenge => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocalPlayerCompletedChallenge += x, x => _data.LocalPlayerCompletedChallenge -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocalPlayerReceivedChallenge => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocalPlayerReceivedChallenge += x, x => _data.LocalPlayerReceivedChallenge -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocalPlayerSelectedChallenge => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocalPlayerSelectedChallenge += x, x => _data.LocalPlayerSelectedChallenge -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemotePlayerCompletedChallenge => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemotePlayerCompletedChallenge += x, x => _data.RemotePlayerCompletedChallenge -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGKFriendRequestComposeViewControllerEvents + { + private readonly global::GameKit.GKFriendRequestComposeViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGKFriendRequestComposeViewControllerEvents(global::GameKit.GKFriendRequestComposeViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinish => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinish += x, x => _data.DidFinish -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGKGameCenterViewControllerEvents + { + private readonly global::GameKit.GKGameCenterViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGKGameCenterViewControllerEvents(global::GameKit.GKGameCenterViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finished += x, x => _data.Finished -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGKLeaderboardViewControllerEvents : global::GameKit.RxGKGameCenterViewControllerEvents + { + private readonly global::GameKit.GKLeaderboardViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGKLeaderboardViewControllerEvents(global::GameKit.GKLeaderboardViewController data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinish => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinish += x, x => _data.DidFinish -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGKMatchEvents + { + private readonly global::GameKit.GKMatch _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGKMatchEvents(global::GameKit.GKMatch data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataReceived => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKDataEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKDataEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataReceivedForRecipient => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKDataReceivedForRecipientEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKDataReceivedForRecipientEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataReceivedForRecipient += x, x => _data.DataReceivedForRecipient -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataReceivedFromPlayer => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKMatchReceivedDataFromRemotePlayerEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKMatchReceivedDataFromRemotePlayerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataReceivedFromPlayer += x, x => _data.DataReceivedFromPlayer -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Failed => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKStateEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKStateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChangedForPlayer => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKMatchConnectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKMatchConnectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChangedForPlayer += x, x => _data.StateChangedForPlayer -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGKMatchmakerViewControllerEvents + { + private readonly global::GameKit.GKMatchmakerViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGKMatchmakerViewControllerEvents(global::GameKit.GKMatchmakerViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFailWithError => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFailWithError += x, x => _data.DidFailWithError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFindHostedPlayers => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKMatchmakingPlayersEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKMatchmakingPlayersEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFindHostedPlayers += x, x => _data.DidFindHostedPlayers -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFindMatch => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKMatchEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKMatchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFindMatch += x, x => _data.DidFindMatch -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFindPlayers => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKPlayersEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKPlayersEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFindPlayers += x, x => _data.DidFindPlayers -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HostedPlayerDidAccept => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKMatchmakingPlayerEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKMatchmakingPlayerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HostedPlayerDidAccept += x, x => _data.HostedPlayerDidAccept -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReceivedAcceptFromHostedPlayer => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKPlayerEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKPlayerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReceivedAcceptFromHostedPlayer += x, x => _data.ReceivedAcceptFromHostedPlayer -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WasCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WasCancelled += x, x => _data.WasCancelled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGKSessionEvents + { + private readonly global::GameKit.GKSession _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGKSessionEvents(global::GameKit.GKSession data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ConnectionFailed => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKPeerConnectionEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKPeerConnectionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ConnectionFailed += x, x => _data.ConnectionFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ConnectionRequest => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKPeerConnectionEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKPeerConnectionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ConnectionRequest += x, x => _data.ConnectionRequest -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Failed => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKPeerConnectionEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKPeerConnectionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PeerChanged => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKPeerChangedStateEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKPeerChangedStateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PeerChanged += x, x => _data.PeerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReceiveData => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKDataReceivedEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKDataReceivedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReceiveData += x, x => _data.ReceiveData -= x); + } +} + +namespace GLKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGLKViewEvents Events(this global::GLKit.GLKView item) => new RxGLKViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGLKViewEvents + { + private readonly global::GLKit.GLKView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGLKViewEvents(global::GLKit.GLKView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawInRect => global::System.Reactive.Linq.Observable.FromEvent, global::GLKit.GLKViewDrawEventArgs>(eventHandler => + { + void Handler(object sender, global::GLKit.GLKViewDrawEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawInRect += x, x => _data.DrawInRect -= x); + } +} + +namespace HomeKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHMAccessoryEvents Events(this global::HomeKit.HMAccessory item) => new RxHMAccessoryEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHMAccessoryBrowserEvents Events(this global::HomeKit.HMAccessoryBrowser item) => new RxHMAccessoryBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHMHomeEvents Events(this global::HomeKit.HMHome item) => new RxHMHomeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHMHomeManagerEvents Events(this global::HomeKit.HMHomeManager item) => new RxHMHomeManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHMAccessoryEvents + { + private readonly global::HomeKit.HMAccessory _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHMAccessoryEvents(global::HomeKit.HMAccessory data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddProfile => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMAccessoryProfileEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMAccessoryProfileEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddProfile += x, x => _data.DidAddProfile -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveProfile => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMAccessoryProfileEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMAccessoryProfileEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveProfile += x, x => _data.DidRemoveProfile -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateAssociatedServiceType => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMAccessoryUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMAccessoryUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateAssociatedServiceType += x, x => _data.DidUpdateAssociatedServiceType -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateFirmwareVersion => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMAccessoryFirmwareVersionEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMAccessoryFirmwareVersionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateFirmwareVersion += x, x => _data.DidUpdateFirmwareVersion -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateName => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateName += x, x => _data.DidUpdateName -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateNameForService => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMAccessoryUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMAccessoryUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateNameForService += x, x => _data.DidUpdateNameForService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateReachability => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateReachability += x, x => _data.DidUpdateReachability -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateServices => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateServices += x, x => _data.DidUpdateServices -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateValueForCharacteristic => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMAccessoryServiceUpdateCharacteristicEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMAccessoryServiceUpdateCharacteristicEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateValueForCharacteristic += x, x => _data.DidUpdateValueForCharacteristic -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHMAccessoryBrowserEvents + { + private readonly global::HomeKit.HMAccessoryBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHMAccessoryBrowserEvents(global::HomeKit.HMAccessoryBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFindNewAccessory => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMAccessoryBrowserEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMAccessoryBrowserEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFindNewAccessory += x, x => _data.DidFindNewAccessory -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveNewAccessory => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMAccessoryBrowserEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMAccessoryBrowserEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveNewAccessory += x, x => _data.DidRemoveNewAccessory -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHMHomeEvents + { + private readonly global::HomeKit.HMHome _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHMHomeEvents(global::HomeKit.HMHome data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddAccessory => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeAccessoryEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeAccessoryEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddAccessory += x, x => _data.DidAddAccessory -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddActionSet => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeActionSetEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeActionSetEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddActionSet += x, x => _data.DidAddActionSet -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddRoom => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeRoomEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeRoomEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddRoom += x, x => _data.DidAddRoom -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddRoomToZone => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeRoomZoneEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeRoomZoneEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddRoomToZone += x, x => _data.DidAddRoomToZone -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddService => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeServiceServiceGroupEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeServiceServiceGroupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddService += x, x => _data.DidAddService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddServiceGroup => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeServiceGroupEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeServiceGroupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddServiceGroup += x, x => _data.DidAddServiceGroup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddTrigger => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeTriggerEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeTriggerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddTrigger += x, x => _data.DidAddTrigger -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddUser => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeUserEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeUserEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddUser += x, x => _data.DidAddUser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddZone => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeZoneEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeZoneEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddZone += x, x => _data.DidAddZone -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEncounterError => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeErrorAccessoryEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeErrorAccessoryEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEncounterError += x, x => _data.DidEncounterError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveAccessory => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeAccessoryEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeAccessoryEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveAccessory += x, x => _data.DidRemoveAccessory -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveActionSet => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeActionSetEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeActionSetEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveActionSet += x, x => _data.DidRemoveActionSet -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveRoom => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeRoomEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeRoomEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveRoom += x, x => _data.DidRemoveRoom -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveRoomFromZone => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeRoomZoneEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeRoomZoneEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveRoomFromZone += x, x => _data.DidRemoveRoomFromZone -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveService => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeServiceServiceGroupEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeServiceServiceGroupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveService += x, x => _data.DidRemoveService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveServiceGroup => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeServiceGroupEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeServiceGroupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveServiceGroup += x, x => _data.DidRemoveServiceGroup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveTrigger => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeTriggerEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeTriggerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveTrigger += x, x => _data.DidRemoveTrigger -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveUser => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeUserEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeUserEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveUser += x, x => _data.DidRemoveUser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveZone => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeZoneEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeZoneEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveZone += x, x => _data.DidRemoveZone -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUnblockAccessory => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeAccessoryEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeAccessoryEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUnblockAccessory += x, x => _data.DidUnblockAccessory -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateAccessControlForCurrentUser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateAccessControlForCurrentUser += x, x => _data.DidUpdateAccessControlForCurrentUser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateActionsForActionSet => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeActionSetEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeActionSetEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateActionsForActionSet += x, x => _data.DidUpdateActionsForActionSet -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateHomeHubState => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeHubStateEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeHubStateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateHomeHubState += x, x => _data.DidUpdateHomeHubState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateNameForActionSet => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeActionSetEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeActionSetEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateNameForActionSet += x, x => _data.DidUpdateNameForActionSet -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateNameForHome => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateNameForHome += x, x => _data.DidUpdateNameForHome -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateNameForRoom => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeRoomEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeRoomEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateNameForRoom += x, x => _data.DidUpdateNameForRoom -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateNameForServiceGroup => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeServiceGroupEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeServiceGroupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateNameForServiceGroup += x, x => _data.DidUpdateNameForServiceGroup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateNameForTrigger => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeTriggerEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeTriggerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateNameForTrigger += x, x => _data.DidUpdateNameForTrigger -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateNameForZone => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeZoneEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeZoneEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateNameForZone += x, x => _data.DidUpdateNameForZone -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateRoom => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeRoomAccessoryEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeRoomAccessoryEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateRoom += x, x => _data.DidUpdateRoom -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateSupportedFeatures => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateSupportedFeatures += x, x => _data.DidUpdateSupportedFeatures -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateTrigger => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeTriggerEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeTriggerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateTrigger += x, x => _data.DidUpdateTrigger -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHMHomeManagerEvents + { + private readonly global::HomeKit.HMHomeManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHMHomeManagerEvents(global::HomeKit.HMHomeManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddHome => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeManagerEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeManagerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddHome += x, x => _data.DidAddHome -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidReceiveAddAccessoryRequest => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeManagerAddAccessoryRequestEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeManagerAddAccessoryRequestEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidReceiveAddAccessoryRequest += x, x => _data.DidReceiveAddAccessoryRequest -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveHome => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeManagerEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeManagerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveHome += x, x => _data.DidRemoveHome -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateAuthorizationStatus => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeManagerAuthorizationStatusEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeManagerAuthorizationStatusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateAuthorizationStatus += x, x => _data.DidUpdateAuthorizationStatus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateHomes => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateHomes += x, x => _data.DidUpdateHomes -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdatePrimaryHome => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdatePrimaryHome += x, x => _data.DidUpdatePrimaryHome -= x); + } +} + +namespace iAd +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxADBannerViewEvents Events(this global::iAd.ADBannerView item) => new RxADBannerViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxADInterstitialAdEvents Events(this global::iAd.ADInterstitialAd item) => new RxADInterstitialAdEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxADBannerViewEvents + { + private readonly global::iAd.ADBannerView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxADBannerViewEvents(global::iAd.ADBannerView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActionFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActionFinished += x, x => _data.ActionFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AdLoaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AdLoaded += x, x => _data.AdLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FailedToReceiveAd => global::System.Reactive.Linq.Observable.FromEvent, global::iAd.AdErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::iAd.AdErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FailedToReceiveAd += x, x => _data.FailedToReceiveAd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillLoad => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillLoad += x, x => _data.WillLoad -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxADInterstitialAdEvents + { + private readonly global::iAd.ADInterstitialAd _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxADInterstitialAdEvents(global::iAd.ADInterstitialAd data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ActionFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ActionFinished += x, x => _data.ActionFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AdLoaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AdLoaded += x, x => _data.AdLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AdUnloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AdUnloaded += x, x => _data.AdUnloaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FailedToReceiveAd => global::System.Reactive.Linq.Observable.FromEvent, global::iAd.ADErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::iAd.ADErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FailedToReceiveAd += x, x => _data.FailedToReceiveAd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillLoad => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillLoad += x, x => _data.WillLoad -= x); + } +} + +namespace MapKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMKMapViewEvents Events(this global::MapKit.MKMapView item) => new RxMKMapViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMKMapViewEvents + { + private readonly global::MapKit.MKMapView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMKMapViewEvents(global::MapKit.MKMapView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CalloutAccessoryControlTapped => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKMapViewAccessoryTappedEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKMapViewAccessoryTappedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CalloutAccessoryControlTapped += x, x => _data.CalloutAccessoryControlTapped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangedDragState => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKMapViewDragStateEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKMapViewDragStateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangedDragState += x, x => _data.ChangedDragState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddAnnotationViews => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKMapViewAnnotationEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKMapViewAnnotationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddAnnotationViews += x, x => _data.DidAddAnnotationViews -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddOverlayRenderers => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKDidAddOverlayRenderersEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKDidAddOverlayRenderersEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddOverlayRenderers += x, x => _data.DidAddOverlayRenderers -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddOverlayViews => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKOverlayViewsEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKOverlayViewsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddOverlayViews += x, x => _data.DidAddOverlayViews -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidChangeUserTrackingMode => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MMapViewUserTrackingEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MMapViewUserTrackingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidChangeUserTrackingMode += x, x => _data.DidChangeUserTrackingMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidChangeVisibleRegion => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidChangeVisibleRegion += x, x => _data.DidChangeVisibleRegion -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDeselectAnnotationView => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKAnnotationViewEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKAnnotationViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDeselectAnnotationView += x, x => _data.DidDeselectAnnotationView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFailToLocateUser => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFailToLocateUser += x, x => _data.DidFailToLocateUser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinishRenderingMap => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKDidFinishRenderingMapEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKDidFinishRenderingMapEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinishRenderingMap += x, x => _data.DidFinishRenderingMap -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidSelectAnnotationView => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKAnnotationViewEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKAnnotationViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidSelectAnnotationView += x, x => _data.DidSelectAnnotationView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidStopLocatingUser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidStopLocatingUser += x, x => _data.DidStopLocatingUser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateUserLocation => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKUserLocationEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKUserLocationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateUserLocation += x, x => _data.DidUpdateUserLocation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingMapFailed => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingMapFailed += x, x => _data.LoadingMapFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MapLoaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MapLoaded += x, x => _data.MapLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKMapViewChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKMapViewChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionWillChange => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKMapViewChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKMapViewChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionWillChange += x, x => _data.RegionWillChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillStartLoadingMap => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillStartLoadingMap += x, x => _data.WillStartLoadingMap -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillStartLocatingUser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillStartLocatingUser += x, x => _data.WillStartLocatingUser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillStartRenderingMap => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillStartRenderingMap += x, x => _data.WillStartRenderingMap -= x); + } +} + +namespace MediaPlayer +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMPMediaPickerControllerEvents Events(this global::MediaPlayer.MPMediaPickerController item) => new RxMPMediaPickerControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMPMediaPickerControllerEvents + { + private readonly global::MediaPlayer.MPMediaPickerController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMPMediaPickerControllerEvents(global::MediaPlayer.MPMediaPickerController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidCancel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidCancel += x, x => _data.DidCancel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsPicked => global::System.Reactive.Linq.Observable.FromEvent, global::MediaPlayer.ItemsPickedEventArgs>(eventHandler => + { + void Handler(object sender, global::MediaPlayer.ItemsPickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsPicked += x, x => _data.ItemsPicked -= x); + } +} + +namespace MessageUI +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMFMailComposeViewControllerEvents Events(this global::MessageUI.MFMailComposeViewController item) => new RxMFMailComposeViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMFMessageComposeViewControllerEvents Events(this global::MessageUI.MFMessageComposeViewController item) => new RxMFMessageComposeViewControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMFMailComposeViewControllerEvents + { + private readonly global::MessageUI.MFMailComposeViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMFMailComposeViewControllerEvents(global::MessageUI.MFMailComposeViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finished => global::System.Reactive.Linq.Observable.FromEvent, global::MessageUI.MFComposeResultEventArgs>(eventHandler => + { + void Handler(object sender, global::MessageUI.MFComposeResultEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finished += x, x => _data.Finished -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMFMessageComposeViewControllerEvents + { + private readonly global::MessageUI.MFMessageComposeViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMFMessageComposeViewControllerEvents(global::MessageUI.MFMessageComposeViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finished => global::System.Reactive.Linq.Observable.FromEvent, global::MessageUI.MFMessageComposeResultEventArgs>(eventHandler => + { + void Handler(object sender, global::MessageUI.MFMessageComposeResultEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finished += x, x => _data.Finished -= x); + } +} + +namespace PassKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPKAddPassesViewControllerEvents Events(this global::PassKit.PKAddPassesViewController item) => new RxPKAddPassesViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPKPaymentAuthorizationViewControllerEvents Events(this global::PassKit.PKPaymentAuthorizationViewController item) => new RxPKPaymentAuthorizationViewControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPKAddPassesViewControllerEvents + { + private readonly global::PassKit.PKAddPassesViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPKAddPassesViewControllerEvents(global::PassKit.PKAddPassesViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finished += x, x => _data.Finished -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPKPaymentAuthorizationViewControllerEvents + { + private readonly global::PassKit.PKPaymentAuthorizationViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPKPaymentAuthorizationViewControllerEvents(global::PassKit.PKPaymentAuthorizationViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAuthorizePayment => global::System.Reactive.Linq.Observable.FromEvent, global::PassKit.PKPaymentAuthorizationEventArgs>(eventHandler => + { + void Handler(object sender, global::PassKit.PKPaymentAuthorizationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAuthorizePayment += x, x => _data.DidAuthorizePayment -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAuthorizePayment2 => global::System.Reactive.Linq.Observable.FromEvent, global::PassKit.PKPaymentAuthorizationResultEventArgs>(eventHandler => + { + void Handler(object sender, global::PassKit.PKPaymentAuthorizationResultEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAuthorizePayment2 += x, x => _data.DidAuthorizePayment2 -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRequestMerchantSessionUpdate => global::System.Reactive.Linq.Observable.FromEvent, global::PassKit.PKPaymentRequestMerchantSessionUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::PassKit.PKPaymentRequestMerchantSessionUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRequestMerchantSessionUpdate += x, x => _data.DidRequestMerchantSessionUpdate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidSelectPaymentMethod => global::System.Reactive.Linq.Observable.FromEvent, global::PassKit.PKPaymentMethodSelectedEventArgs>(eventHandler => + { + void Handler(object sender, global::PassKit.PKPaymentMethodSelectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidSelectPaymentMethod += x, x => _data.DidSelectPaymentMethod -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidSelectPaymentMethod2 => global::System.Reactive.Linq.Observable.FromEvent, global::PassKit.PKPaymentRequestPaymentMethodUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::PassKit.PKPaymentRequestPaymentMethodUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidSelectPaymentMethod2 += x, x => _data.DidSelectPaymentMethod2 -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidSelectShippingAddress => global::System.Reactive.Linq.Observable.FromEvent, global::PassKit.PKPaymentShippingAddressSelectedEventArgs>(eventHandler => + { + void Handler(object sender, global::PassKit.PKPaymentShippingAddressSelectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidSelectShippingAddress += x, x => _data.DidSelectShippingAddress -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidSelectShippingContact => global::System.Reactive.Linq.Observable.FromEvent, global::PassKit.PKPaymentSelectedContactEventArgs>(eventHandler => + { + void Handler(object sender, global::PassKit.PKPaymentSelectedContactEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidSelectShippingContact += x, x => _data.DidSelectShippingContact -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidSelectShippingContact2 => global::System.Reactive.Linq.Observable.FromEvent, global::PassKit.PKPaymentRequestShippingContactUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::PassKit.PKPaymentRequestShippingContactUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidSelectShippingContact2 += x, x => _data.DidSelectShippingContact2 -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidSelectShippingMethod => global::System.Reactive.Linq.Observable.FromEvent, global::PassKit.PKPaymentShippingMethodSelectedEventArgs>(eventHandler => + { + void Handler(object sender, global::PassKit.PKPaymentShippingMethodSelectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidSelectShippingMethod += x, x => _data.DidSelectShippingMethod -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidSelectShippingMethod2 => global::System.Reactive.Linq.Observable.FromEvent, global::PassKit.PKPaymentRequestShippingMethodUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::PassKit.PKPaymentRequestShippingMethodUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidSelectShippingMethod2 += x, x => _data.DidSelectShippingMethod2 -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaymentAuthorizationViewControllerDidFinish => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaymentAuthorizationViewControllerDidFinish += x, x => _data.PaymentAuthorizationViewControllerDidFinish -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillAuthorizePayment => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillAuthorizePayment += x, x => _data.WillAuthorizePayment -= x); + } +} + +namespace PdfKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPdfDocumentEvents Events(this global::PdfKit.PdfDocument item) => new RxPdfDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPdfViewEvents Events(this global::PdfKit.PdfView item) => new RxPdfViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPdfDocumentEvents + { + private readonly global::PdfKit.PdfDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPdfDocumentEvents(global::PdfKit.PdfDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidBeginDocumentFind => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidBeginDocumentFind += x, x => _data.DidBeginDocumentFind -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidMatchString => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidMatchString += x, x => _data.DidMatchString -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUnlock => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUnlock += x, x => _data.DidUnlock -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FindFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FindFinished += x, x => _data.FindFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MatchFound => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MatchFound += x, x => _data.MatchFound -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageFindFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageFindFinished += x, x => _data.PageFindFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageFindStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageFindStarted += x, x => _data.PageFindStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPdfViewEvents + { + private readonly global::PdfKit.PdfView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPdfViewEvents(global::PdfKit.PdfView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OpenPdf => global::System.Reactive.Linq.Observable.FromEvent, global::PdfKit.PdfViewActionEventArgs>(eventHandler => + { + void Handler(object sender, global::PdfKit.PdfViewActionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OpenPdf += x, x => _data.OpenPdf -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PerformFind => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PerformFind += x, x => _data.PerformFind -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PerformGoToPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PerformGoToPage += x, x => _data.PerformGoToPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillClickOnLink => global::System.Reactive.Linq.Observable.FromEvent, global::PdfKit.PdfViewUrlEventArgs>(eventHandler => + { + void Handler(object sender, global::PdfKit.PdfViewUrlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillClickOnLink += x, x => _data.WillClickOnLink -= x); + } +} + +namespace QuickLook +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxQLPreviewControllerEvents Events(this global::QuickLook.QLPreviewController item) => new RxQLPreviewControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxQLPreviewControllerEvents + { + private readonly global::QuickLook.QLPreviewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxQLPreviewControllerEvents(global::QuickLook.QLPreviewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDismiss => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDismiss += x, x => _data.DidDismiss -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidSaveEditedCopy => global::System.Reactive.Linq.Observable.FromEvent, global::QuickLook.QLPreviewControllerDelegateDidSaveEventArgs>(eventHandler => + { + void Handler(object sender, global::QuickLook.QLPreviewControllerDelegateDidSaveEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidSaveEditedCopy += x, x => _data.DidSaveEditedCopy -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateContents => global::System.Reactive.Linq.Observable.FromEvent, global::QuickLook.QLPreviewControllerDelegateDidUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::QuickLook.QLPreviewControllerDelegateDidUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateContents += x, x => _data.DidUpdateContents -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillDismiss => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillDismiss += x, x => _data.WillDismiss -= x); + } +} + +namespace SceneKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSCNPhysicsWorldEvents Events(this global::SceneKit.SCNPhysicsWorld item) => new RxSCNPhysicsWorldEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSCNPhysicsWorldEvents + { + private readonly global::SceneKit.SCNPhysicsWorld _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSCNPhysicsWorldEvents(global::SceneKit.SCNPhysicsWorld data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidBeginContact => global::System.Reactive.Linq.Observable.FromEvent, global::SceneKit.SCNPhysicsContactEventArgs>(eventHandler => + { + void Handler(object sender, global::SceneKit.SCNPhysicsContactEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidBeginContact += x, x => _data.DidBeginContact -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEndContact => global::System.Reactive.Linq.Observable.FromEvent, global::SceneKit.SCNPhysicsContactEventArgs>(eventHandler => + { + void Handler(object sender, global::SceneKit.SCNPhysicsContactEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEndContact += x, x => _data.DidEndContact -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateContact => global::System.Reactive.Linq.Observable.FromEvent, global::SceneKit.SCNPhysicsContactEventArgs>(eventHandler => + { + void Handler(object sender, global::SceneKit.SCNPhysicsContactEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateContact += x, x => _data.DidUpdateContact -= x); + } +} + +namespace SpriteKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSKPhysicsWorldEvents Events(this global::SpriteKit.SKPhysicsWorld item) => new RxSKPhysicsWorldEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSKPhysicsWorldEvents + { + private readonly global::SpriteKit.SKPhysicsWorld _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSKPhysicsWorldEvents(global::SpriteKit.SKPhysicsWorld data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidBeginContact => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidBeginContact += x, x => _data.DidBeginContact -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEndContact => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEndContact += x, x => _data.DidEndContact -= x); + } +} + +namespace StoreKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSKProductsRequestEvents Events(this global::StoreKit.SKProductsRequest item) => new RxSKProductsRequestEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSKRequestEvents Events(this global::StoreKit.SKRequest item) => new RxSKRequestEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSKStoreProductViewControllerEvents Events(this global::StoreKit.SKStoreProductViewController item) => new RxSKStoreProductViewControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSKProductsRequestEvents : global::StoreKit.RxSKRequestEvents + { + private readonly global::StoreKit.SKProductsRequest _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSKProductsRequestEvents(global::StoreKit.SKProductsRequest data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReceivedResponse => global::System.Reactive.Linq.Observable.FromEvent, global::StoreKit.SKProductsRequestResponseEventArgs>(eventHandler => + { + void Handler(object sender, global::StoreKit.SKProductsRequestResponseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReceivedResponse += x, x => _data.ReceivedResponse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSKRequestEvents + { + private readonly global::StoreKit.SKRequest _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSKRequestEvents(global::StoreKit.SKRequest data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestFailed => global::System.Reactive.Linq.Observable.FromEvent, global::StoreKit.SKRequestErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::StoreKit.SKRequestErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestFailed += x, x => _data.RequestFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestFinished += x, x => _data.RequestFinished -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSKStoreProductViewControllerEvents + { + private readonly global::StoreKit.SKStoreProductViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSKStoreProductViewControllerEvents(global::StoreKit.SKStoreProductViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finished += x, x => _data.Finished -= x); + } +} + +namespace UIKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSTextStorageEvents Events(this global::UIKit.NSTextStorage item) => new RxNSTextStorageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIAccelerometerEvents Events(this global::UIKit.UIAccelerometer item) => new RxUIAccelerometerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIActionSheetEvents Events(this global::UIKit.UIActionSheet item) => new RxUIActionSheetEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIAlertViewEvents Events(this global::UIKit.UIAlertView item) => new RxUIAlertViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIBarButtonItemEvents Events(this global::UIKit.UIBarButtonItem item) => new RxUIBarButtonItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUICollisionBehaviorEvents Events(this global::UIKit.UICollisionBehavior item) => new RxUICollisionBehaviorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIControlEvents Events(this global::UIKit.UIControl item) => new RxUIControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIDocumentInteractionControllerEvents Events(this global::UIKit.UIDocumentInteractionController item) => new RxUIDocumentInteractionControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIDocumentMenuViewControllerEvents Events(this global::UIKit.UIDocumentMenuViewController item) => new RxUIDocumentMenuViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIDocumentPickerViewControllerEvents Events(this global::UIKit.UIDocumentPickerViewController item) => new RxUIDocumentPickerViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIImagePickerControllerEvents Events(this global::UIKit.UIImagePickerController item) => new RxUIImagePickerControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIPageViewControllerEvents Events(this global::UIKit.UIPageViewController item) => new RxUIPageViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIPopoverControllerEvents Events(this global::UIKit.UIPopoverController item) => new RxUIPopoverControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIPopoverPresentationControllerEvents Events(this global::UIKit.UIPopoverPresentationController item) => new RxUIPopoverPresentationControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIPreviewInteractionEvents Events(this global::UIKit.UIPreviewInteraction item) => new RxUIPreviewInteractionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIPrintInteractionControllerEvents Events(this global::UIKit.UIPrintInteractionController item) => new RxUIPrintInteractionControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIScrollViewEvents Events(this global::UIKit.UIScrollView item) => new RxUIScrollViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUISearchBarEvents Events(this global::UIKit.UISearchBar item) => new RxUISearchBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUISplitViewControllerEvents Events(this global::UIKit.UISplitViewController item) => new RxUISplitViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUITabBarEvents Events(this global::UIKit.UITabBar item) => new RxUITabBarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUITabBarControllerEvents Events(this global::UIKit.UITabBarController item) => new RxUITabBarControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUITextFieldEvents Events(this global::UIKit.UITextField item) => new RxUITextFieldEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUITextViewEvents Events(this global::UIKit.UITextView item) => new RxUITextViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIVideoEditorControllerEvents Events(this global::UIKit.UIVideoEditorController item) => new RxUIVideoEditorControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxUIWebViewEvents Events(this global::UIKit.UIWebView item) => new RxUIWebViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSTextStorageEvents + { + private readonly global::UIKit.NSTextStorage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSTextStorageEvents(global::UIKit.NSTextStorage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidProcessEditing => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.NSTextStorageEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.NSTextStorageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidProcessEditing += x, x => _data.DidProcessEditing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillProcessEditing => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.NSTextStorageEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.NSTextStorageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillProcessEditing += x, x => _data.WillProcessEditing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIAccelerometerEvents + { + private readonly global::UIKit.UIAccelerometer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIAccelerometerEvents(global::UIKit.UIAccelerometer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Acceleration => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIAccelerometerEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIAccelerometerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Acceleration += x, x => _data.Acceleration -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIActionSheetEvents + { + private readonly global::UIKit.UIActionSheet _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIActionSheetEvents(global::UIKit.UIActionSheet data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Canceled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Canceled += x, x => _data.Canceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIButtonEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Clicked += x, x => _data.Clicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Dismissed => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIButtonEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Presented => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Presented += x, x => _data.Presented -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillDismiss => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIButtonEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillDismiss += x, x => _data.WillDismiss -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillPresent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillPresent += x, x => _data.WillPresent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIAlertViewEvents + { + private readonly global::UIKit.UIAlertView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIAlertViewEvents(global::UIKit.UIAlertView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Canceled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Canceled += x, x => _data.Canceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIButtonEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Clicked += x, x => _data.Clicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Dismissed => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIButtonEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Presented => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Presented += x, x => _data.Presented -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillDismiss => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIButtonEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIButtonEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillDismiss += x, x => _data.WillDismiss -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillPresent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillPresent += x, x => _data.WillPresent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIBarButtonItemEvents + { + private readonly global::UIKit.UIBarButtonItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIBarButtonItemEvents(global::UIKit.UIBarButtonItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Clicked += x, x => _data.Clicked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUICollisionBehaviorEvents + { + private readonly global::UIKit.UICollisionBehavior _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUICollisionBehaviorEvents(global::UIKit.UICollisionBehavior data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeganBoundaryContact => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UICollisionBeganBoundaryContactEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UICollisionBeganBoundaryContactEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeganBoundaryContact += x, x => _data.BeganBoundaryContact -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeganContact => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UICollisionBeganContactEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UICollisionBeganContactEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeganContact += x, x => _data.BeganContact -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndedBoundaryContact => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UICollisionEndedBoundaryContactEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UICollisionEndedBoundaryContactEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndedBoundaryContact += x, x => _data.EndedBoundaryContact -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndedContact => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UICollisionEndedContactEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UICollisionEndedContactEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndedContact += x, x => _data.EndedContact -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIControlEvents + { + private readonly global::UIKit.UIControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIControlEvents(global::UIKit.UIControl data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllEditingEvents => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllEditingEvents += x, x => _data.AllEditingEvents -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllEvents => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllEvents += x, x => _data.AllEvents -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AllTouchEvents => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AllTouchEvents += x, x => _data.AllTouchEvents -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingChanged += x, x => _data.EditingChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingDidBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingDidBegin += x, x => _data.EditingDidBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingDidEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingDidEnd += x, x => _data.EditingDidEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingDidEndOnExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingDidEndOnExit += x, x => _data.EditingDidEndOnExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PrimaryActionTriggered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PrimaryActionTriggered += x, x => _data.PrimaryActionTriggered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchCancel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchCancel += x, x => _data.TouchCancel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDownRepeat => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDownRepeat += x, x => _data.TouchDownRepeat -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDragEnter += x, x => _data.TouchDragEnter -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDragExit => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDragExit += x, x => _data.TouchDragExit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDragInside => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDragInside += x, x => _data.TouchDragInside -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchDragOutside => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchDragOutside += x, x => _data.TouchDragOutside -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUpInside => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUpInside += x, x => _data.TouchUpInside -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TouchUpOutside => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TouchUpOutside += x, x => _data.TouchUpOutside -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIDocumentInteractionControllerEvents + { + private readonly global::UIKit.UIDocumentInteractionController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIDocumentInteractionControllerEvents(global::UIKit.UIDocumentInteractionController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDismissOpenInMenu => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDismissOpenInMenu += x, x => _data.DidDismissOpenInMenu -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDismissOptionsMenu => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDismissOptionsMenu += x, x => _data.DidDismissOptionsMenu -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEndPreview => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEndPreview += x, x => _data.DidEndPreview -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEndSendingToApplication => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIDocumentSendingToApplicationEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIDocumentSendingToApplicationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEndSendingToApplication += x, x => _data.DidEndSendingToApplication -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillBeginPreview => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillBeginPreview += x, x => _data.WillBeginPreview -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillBeginSendingToApplication => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIDocumentSendingToApplicationEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIDocumentSendingToApplicationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillBeginSendingToApplication += x, x => _data.WillBeginSendingToApplication -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillPresentOpenInMenu => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillPresentOpenInMenu += x, x => _data.WillPresentOpenInMenu -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillPresentOptionsMenu => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillPresentOptionsMenu += x, x => _data.WillPresentOptionsMenu -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIDocumentMenuViewControllerEvents + { + private readonly global::UIKit.UIDocumentMenuViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIDocumentMenuViewControllerEvents(global::UIKit.UIDocumentMenuViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidPickDocumentPicker => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIDocumentMenuDocumentPickedEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIDocumentMenuDocumentPickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidPickDocumentPicker += x, x => _data.DidPickDocumentPicker -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WasCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WasCancelled += x, x => _data.WasCancelled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIDocumentPickerViewControllerEvents + { + private readonly global::UIKit.UIDocumentPickerViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIDocumentPickerViewControllerEvents(global::UIKit.UIDocumentPickerViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidPickDocument => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIDocumentPickedEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIDocumentPickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidPickDocument += x, x => _data.DidPickDocument -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidPickDocumentAtUrls => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIDocumentPickedAtUrlsEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIDocumentPickedAtUrlsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidPickDocumentAtUrls += x, x => _data.DidPickDocumentAtUrls -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WasCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WasCancelled += x, x => _data.WasCancelled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIImagePickerControllerEvents + { + private readonly global::UIKit.UIImagePickerController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIImagePickerControllerEvents(global::UIKit.UIImagePickerController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Canceled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Canceled += x, x => _data.Canceled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FinishedPickingImage => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIImagePickerImagePickedEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIImagePickerImagePickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FinishedPickingImage += x, x => _data.FinishedPickingImage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FinishedPickingMedia => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIImagePickerMediaPickedEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIImagePickerMediaPickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FinishedPickingMedia += x, x => _data.FinishedPickingMedia -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIPageViewControllerEvents + { + private readonly global::UIKit.UIPageViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIPageViewControllerEvents(global::UIKit.UIPageViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinishAnimating => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIPageViewFinishedAnimationEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIPageViewFinishedAnimationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinishAnimating += x, x => _data.DidFinishAnimating -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillTransition => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIPageViewControllerTransitionEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIPageViewControllerTransitionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillTransition += x, x => _data.WillTransition -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIPopoverControllerEvents + { + private readonly global::UIKit.UIPopoverController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIPopoverControllerEvents(global::UIKit.UIPopoverController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDismiss => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDismiss += x, x => _data.DidDismiss -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillReposition => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIPopoverControllerRepositionEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIPopoverControllerRepositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillReposition += x, x => _data.WillReposition -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIPopoverPresentationControllerEvents + { + private readonly global::UIKit.UIPopoverPresentationController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIPopoverPresentationControllerEvents(global::UIKit.UIPopoverPresentationController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDismiss => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDismiss += x, x => _data.DidDismiss -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PrepareForPresentation => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PrepareForPresentation += x, x => _data.PrepareForPresentation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillReposition => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIPopoverPresentationControllerRepositionEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIPopoverPresentationControllerRepositionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillReposition += x, x => _data.WillReposition -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIPreviewInteractionEvents + { + private readonly global::UIKit.UIPreviewInteraction _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIPreviewInteractionEvents(global::UIKit.UIPreviewInteraction data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidCancel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidCancel += x, x => _data.DidCancel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateCommit => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.NSPreviewInteractionPreviewUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.NSPreviewInteractionPreviewUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateCommit += x, x => _data.DidUpdateCommit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdatePreviewTransition => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.NSPreviewInteractionPreviewUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.NSPreviewInteractionPreviewUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdatePreviewTransition += x, x => _data.DidUpdatePreviewTransition -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIPrintInteractionControllerEvents + { + private readonly global::UIKit.UIPrintInteractionController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIPrintInteractionControllerEvents(global::UIKit.UIPrintInteractionController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDismissPrinterOptions => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDismissPrinterOptions += x, x => _data.DidDismissPrinterOptions -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinishJob => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinishJob += x, x => _data.DidFinishJob -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidPresentPrinterOptions => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidPresentPrinterOptions += x, x => _data.DidPresentPrinterOptions -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillDismissPrinterOptions => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillDismissPrinterOptions += x, x => _data.WillDismissPrinterOptions -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillPresentPrinterOptions => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillPresentPrinterOptions += x, x => _data.WillPresentPrinterOptions -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillStartJob => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillStartJob += x, x => _data.WillStartJob -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIScrollViewEvents + { + private readonly global::UIKit.UIScrollView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIScrollViewEvents(global::UIKit.UIScrollView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecelerationEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecelerationEnded += x, x => _data.DecelerationEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecelerationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecelerationStarted += x, x => _data.DecelerationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidChangeAdjustedContentInset => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidChangeAdjustedContentInset += x, x => _data.DidChangeAdjustedContentInset -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidZoom => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidZoom += x, x => _data.DidZoom -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DraggingEnded => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.DraggingEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.DraggingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DraggingEnded += x, x => _data.DraggingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DraggingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DraggingStarted += x, x => _data.DraggingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollAnimationEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollAnimationEnded += x, x => _data.ScrollAnimationEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrolledToTop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrolledToTop += x, x => _data.ScrolledToTop -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillEndDragging => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.WillEndDraggingEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.WillEndDraggingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillEndDragging += x, x => _data.WillEndDragging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ZoomingEnded => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.ZoomingEndedEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.ZoomingEndedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ZoomingEnded += x, x => _data.ZoomingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ZoomingStarted => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIScrollViewZoomingEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIScrollViewZoomingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ZoomingStarted += x, x => _data.ZoomingStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUISearchBarEvents + { + private readonly global::UIKit.UISearchBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUISearchBarEvents(global::UIKit.UISearchBar data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BookmarkButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BookmarkButtonClicked += x, x => _data.BookmarkButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CancelButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CancelButtonClicked += x, x => _data.CancelButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ListButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ListButtonClicked += x, x => _data.ListButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OnEditingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OnEditingStarted += x, x => _data.OnEditingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OnEditingStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OnEditingStopped += x, x => _data.OnEditingStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchButtonClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchButtonClicked += x, x => _data.SearchButtonClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectedScopeButtonIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISearchBarButtonIndexEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UISearchBarButtonIndexEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectedScopeButtonIndexChanged += x, x => _data.SelectedScopeButtonIndexChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISearchBarTextChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UISearchBarTextChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUISplitViewControllerEvents + { + private readonly global::UIKit.UISplitViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUISplitViewControllerEvents(global::UIKit.UISplitViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidCollapse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidCollapse += x, x => _data.DidCollapse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidExpand => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidExpand += x, x => _data.DidExpand -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InteractivePresentationGestureDidEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InteractivePresentationGestureDidEnd += x, x => _data.InteractivePresentationGestureDidEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InteractivePresentationGestureWillBegin => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InteractivePresentationGestureWillBegin += x, x => _data.InteractivePresentationGestureWillBegin -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillChangeDisplayMode => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewControllerDisplayModeEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UISplitViewControllerDisplayModeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillChangeDisplayMode += x, x => _data.WillChangeDisplayMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillHideColumn => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewControllerWillShowHideColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UISplitViewControllerWillShowHideColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillHideColumn += x, x => _data.WillHideColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillHideViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewHideEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UISplitViewHideEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillHideViewController += x, x => _data.WillHideViewController -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillPresentViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewPresentEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UISplitViewPresentEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillPresentViewController += x, x => _data.WillPresentViewController -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillShowColumn => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewControllerWillShowHideColumnEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UISplitViewControllerWillShowHideColumnEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillShowColumn += x, x => _data.WillShowColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillShowViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewShowEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UISplitViewShowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillShowViewController += x, x => _data.WillShowViewController -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUITabBarEvents + { + private readonly global::UIKit.UITabBar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUITabBarEvents(global::UIKit.UITabBar data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidBeginCustomizingItems => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarItemsEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UITabBarItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidBeginCustomizingItems += x, x => _data.DidBeginCustomizingItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEndCustomizingItems => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarFinalItemsEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UITabBarFinalItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEndCustomizingItems += x, x => _data.DidEndCustomizingItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarItemEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UITabBarItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillBeginCustomizingItems => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarItemsEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UITabBarItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillBeginCustomizingItems += x, x => _data.WillBeginCustomizingItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillEndCustomizingItems => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarFinalItemsEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UITabBarFinalItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillEndCustomizingItems += x, x => _data.WillEndCustomizingItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUITabBarControllerEvents + { + private readonly global::UIKit.UITabBarController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUITabBarControllerEvents(global::UIKit.UITabBarController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FinishedCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FinishedCustomizingViewControllers += x, x => _data.FinishedCustomizingViewControllers -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OnCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UITabBarCustomizeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OnCustomizingViewControllers += x, x => _data.OnCustomizingViewControllers -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OnEndCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OnEndCustomizingViewControllers += x, x => _data.OnEndCustomizingViewControllers -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ViewControllerSelected => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarSelectionEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UITabBarSelectionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ViewControllerSelected += x, x => _data.ViewControllerSelected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUITextFieldEvents : global::UIKit.RxUIControlEvents + { + private readonly global::UIKit.UITextField _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUITextFieldEvents(global::UIKit.UITextField data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Ended => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Ended += x, x => _data.Ended -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndedWithReason => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITextFieldEditingEndedEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UITextFieldEditingEndedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndedWithReason += x, x => _data.EndedWithReason -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Started => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Started += x, x => _data.Started -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUITextViewEvents : global::UIKit.RxUIScrollViewEvents + { + private readonly global::UIKit.UITextView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUITextViewEvents(global::UIKit.UITextView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Ended => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Ended += x, x => _data.Ended -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Started => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Started += x, x => _data.Started -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIVideoEditorControllerEvents + { + private readonly global::UIKit.UIVideoEditorController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIVideoEditorControllerEvents(global::UIKit.UIVideoEditorController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Failed => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Saved => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIPathEventArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIPathEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Saved += x, x => _data.Saved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserCancelled += x, x => _data.UserCancelled -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxUIWebViewEvents + { + private readonly global::UIKit.UIWebView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxUIWebViewEvents(global::UIKit.UIWebView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadError => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIWebErrorArgs>(eventHandler => + { + void Handler(object sender, global::UIKit.UIWebErrorArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadError += x, x => _data.LoadError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadFinished += x, x => _data.LoadFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadStarted += x, x => _data.LoadStarted -= x); + } +} + +namespace AudioToolbox +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AudioSessionAudioInputBecameAvailable => global::System.Reactive.Linq.Observable.FromEvent, bool>(eventHandler => + { + void Handler(bool obj) => eventHandler(obj); + return Handler; + }, x => global::AudioToolbox.AudioSession.AudioInputBecameAvailable += x, x => global::AudioToolbox.AudioSession.AudioInputBecameAvailable -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AudioSessionAudioRouteChanged => global::System.Reactive.Linq.Observable.FromEvent, global::AudioToolbox.AudioSessionRouteChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::AudioToolbox.AudioSessionRouteChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => global::AudioToolbox.AudioSession.AudioRouteChanged += x, x => global::AudioToolbox.AudioSession.AudioRouteChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AudioSessionCurrentHardwareOutputVolumeChanged => global::System.Reactive.Linq.Observable.FromEvent, float>(eventHandler => + { + void Handler(float obj) => eventHandler(obj); + return Handler; + }, x => global::AudioToolbox.AudioSession.CurrentHardwareOutputVolumeChanged += x, x => global::AudioToolbox.AudioSession.CurrentHardwareOutputVolumeChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AudioSessionInputGainBecameAvailable => global::System.Reactive.Linq.Observable.FromEvent, bool>(eventHandler => + { + void Handler(bool obj) => eventHandler(obj); + return Handler; + }, x => global::AudioToolbox.AudioSession.InputGainBecameAvailable += x, x => global::AudioToolbox.AudioSession.InputGainBecameAvailable -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AudioSessionInputGainScalarChanged => global::System.Reactive.Linq.Observable.FromEvent, float>(eventHandler => + { + void Handler(float obj) => eventHandler(obj); + return Handler; + }, x => global::AudioToolbox.AudioSession.InputGainScalarChanged += x, x => global::AudioToolbox.AudioSession.InputGainScalarChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AudioSessionInputSourcesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::AudioToolbox.AccessoryInfo[]>(eventHandler => + { + void Handler(global::AudioToolbox.AccessoryInfo[] obj) => eventHandler(obj); + return Handler; + }, x => global::AudioToolbox.AudioSession.InputSourcesChanged += x, x => global::AudioToolbox.AudioSession.InputSourcesChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AudioSessionInterrupted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::AudioToolbox.AudioSession.Interrupted += x, x => global::AudioToolbox.AudioSession.Interrupted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AudioSessionOutputDestinationsChanged => global::System.Reactive.Linq.Observable.FromEvent, global::AudioToolbox.AccessoryInfo[]>(eventHandler => + { + void Handler(global::AudioToolbox.AccessoryInfo[] obj) => eventHandler(obj); + return Handler; + }, x => global::AudioToolbox.AudioSession.OutputDestinationsChanged += x, x => global::AudioToolbox.AudioSession.OutputDestinationsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AudioSessionResumed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => global::AudioToolbox.AudioSession.Resumed += x, x => global::AudioToolbox.AudioSession.Resumed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AudioSessionServerDied => global::System.Reactive.Linq.Observable.FromEvent, bool>(eventHandler => + { + void Handler(bool obj) => eventHandler(obj); + return Handler; + }, x => global::AudioToolbox.AudioSession.ServerDied += x, x => global::AudioToolbox.AudioSession.ServerDied -= x); + } +} + +namespace ObjCRuntime +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RuntimeMarshalManagedException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::ObjCRuntime.MarshalManagedExceptionEventArgs args) => eventHandler(args); + return Handler; + }, x => global::ObjCRuntime.Runtime.MarshalManagedException += x, x => global::ObjCRuntime.Runtime.MarshalManagedException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RuntimeMarshalObjectiveCException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::ObjCRuntime.MarshalObjectiveCExceptionEventArgs args) => eventHandler(args); + return Handler; + }, x => global::ObjCRuntime.Runtime.MarshalObjectiveCException += x, x => global::ObjCRuntime.Runtime.MarshalObjectiveCException -= x); + } +} + +namespace AddressBookUI +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class ABNewPersonViewControllerDelegateRx : global::AddressBookUI.ABNewPersonViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AddressBookUI.ABNewPersonViewController controller, global::AddressBook.ABPerson person)> _didCompleteWithNewPerson = new Pharmacist.Common.SingleAwaitSubject<(global::AddressBookUI.ABNewPersonViewController controller, global::AddressBook.ABPerson person)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AddressBookUI.ABNewPersonViewController controller, global::AddressBook.ABPerson person)> DidCompleteWithNewPersonObs => _didCompleteWithNewPerson; + /// + public override void DidCompleteWithNewPerson(global::AddressBookUI.ABNewPersonViewController controller, global::AddressBook.ABPerson person) => _didCompleteWithNewPerson.OnNext((controller, person)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class ABPeoplePickerNavigationControllerDelegateRx : global::AddressBookUI.ABPeoplePickerNavigationControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _cancelled = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AddressBookUI.ABPeoplePickerNavigationController peoplePicker, global::AddressBook.ABPerson selectedPerson, int propertyId, int identifier)> _didSelectPerson = new Pharmacist.Common.SingleAwaitSubject<(global::AddressBookUI.ABPeoplePickerNavigationController peoplePicker, global::AddressBook.ABPerson selectedPerson, int propertyId, int identifier)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable CancelledObs => _cancelled; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AddressBookUI.ABPeoplePickerNavigationController peoplePicker, global::AddressBook.ABPerson selectedPerson, int propertyId, int identifier)> DidSelectPersonObs => _didSelectPerson; + /// + public override void Cancelled(global::AddressBookUI.ABPeoplePickerNavigationController peoplePicker) => _cancelled.OnNext(peoplePicker); + /// + public override void DidSelectPerson(global::AddressBookUI.ABPeoplePickerNavigationController peoplePicker, global::AddressBook.ABPerson selectedPerson, int propertyId, int identifier) => _didSelectPerson.OnNext((peoplePicker, selectedPerson, propertyId, identifier)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class ABUnknownPersonViewControllerDelegateRx : global::AddressBookUI.ABUnknownPersonViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AddressBookUI.ABUnknownPersonViewController unknownPersonView, global::AddressBook.ABPerson person)> _didResolveToPerson = new Pharmacist.Common.SingleAwaitSubject<(global::AddressBookUI.ABUnknownPersonViewController unknownPersonView, global::AddressBook.ABPerson person)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AddressBookUI.ABUnknownPersonViewController unknownPersonView, global::AddressBook.ABPerson person)> DidResolveToPersonObs => _didResolveToPerson; + /// + public override void DidResolveToPerson(global::AddressBookUI.ABUnknownPersonViewController unknownPersonView, global::AddressBook.ABPerson person) => _didResolveToPerson.OnNext((unknownPersonView, person)); + } +} + +namespace ARKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class ARCoachingOverlayViewDelegateRx : global::ARKit.ARCoachingOverlayViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didDeactivate = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didRequestSessionReset = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willActivate = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDeactivateObs => _didDeactivate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidRequestSessionResetObs => _didRequestSessionReset; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillActivateObs => _willActivate; + /// + public override void DidDeactivate(global::ARKit.ARCoachingOverlayView coachingOverlayView) => _didDeactivate.OnNext(coachingOverlayView); + /// + public override void DidRequestSessionReset(global::ARKit.ARCoachingOverlayView coachingOverlayView) => _didRequestSessionReset.OnNext(coachingOverlayView); + /// + public override void WillActivate(global::ARKit.ARCoachingOverlayView coachingOverlayView) => _willActivate.OnNext(coachingOverlayView); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class ARSCNViewDelegateRx : global::ARKit.ARSCNViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARCamera camera)> _cameraDidChangeTrackingState = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARCamera camera)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor)> _didAddNode = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> _didApplyAnimations = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double atTime)> _didApplyConstraints = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double atTime)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARGeoTrackingStatus geoTrackingStatus)> _didChangeGeoTrackingStatus = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARGeoTrackingStatus geoTrackingStatus)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::Foundation.NSError error)> _didFail = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::CoreMedia.CMSampleBuffer audioSampleBuffer)> _didOutputAudioSampleBuffer = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::CoreMedia.CMSampleBuffer audioSampleBuffer)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARCollaborationData data)> _didOutputCollaborationData = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARCollaborationData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor)> _didRemoveNode = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> _didRenderScene = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> _didSimulatePhysics = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor)> _didUpdateNode = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _interruptionEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> _update = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _wasInterrupted = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> _willRenderScene = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor)> _willUpdateNode = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::ARKit.ARCamera camera)> CameraDidChangeTrackingStateObs => _cameraDidChangeTrackingState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor)> DidAddNodeObs => _didAddNode; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> DidApplyAnimationsObs => _didApplyAnimations; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double atTime)> DidApplyConstraintsObs => _didApplyConstraints; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::ARKit.ARGeoTrackingStatus geoTrackingStatus)> DidChangeGeoTrackingStatusObs => _didChangeGeoTrackingStatus; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::Foundation.NSError error)> DidFailObs => _didFail; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::CoreMedia.CMSampleBuffer audioSampleBuffer)> DidOutputAudioSampleBufferObs => _didOutputAudioSampleBuffer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::ARKit.ARCollaborationData data)> DidOutputCollaborationDataObs => _didOutputCollaborationData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor)> DidRemoveNodeObs => _didRemoveNode; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> DidRenderSceneObs => _didRenderScene; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> DidSimulatePhysicsObs => _didSimulatePhysics; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor)> DidUpdateNodeObs => _didUpdateNode; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable InterruptionEndedObs => _interruptionEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> UpdateObs => _update; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WasInterruptedObs => _wasInterrupted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> WillRenderSceneObs => _willRenderScene; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor)> WillUpdateNodeObs => _willUpdateNode; + /// + public override void CameraDidChangeTrackingState(global::ARKit.ARSession session, global::ARKit.ARCamera camera) => _cameraDidChangeTrackingState.OnNext((session, camera)); + /// + public override void DidAddNode(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor) => _didAddNode.OnNext((renderer, node, anchor)); + /// + public override void DidApplyAnimations(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds) => _didApplyAnimations.OnNext((renderer, timeInSeconds)); + /// + public override void DidApplyConstraints(global::SceneKit.ISCNSceneRenderer renderer, double atTime) => _didApplyConstraints.OnNext((renderer, atTime)); + /// + public override void DidChangeGeoTrackingStatus(global::ARKit.ARSession session, global::ARKit.ARGeoTrackingStatus geoTrackingStatus) => _didChangeGeoTrackingStatus.OnNext((session, geoTrackingStatus)); + /// + public override void DidFail(global::ARKit.ARSession session, global::Foundation.NSError error) => _didFail.OnNext((session, error)); + /// + public override void DidOutputAudioSampleBuffer(global::ARKit.ARSession session, global::CoreMedia.CMSampleBuffer audioSampleBuffer) => _didOutputAudioSampleBuffer.OnNext((session, audioSampleBuffer)); + /// + public override void DidOutputCollaborationData(global::ARKit.ARSession session, global::ARKit.ARCollaborationData data) => _didOutputCollaborationData.OnNext((session, data)); + /// + public override void DidRemoveNode(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor) => _didRemoveNode.OnNext((renderer, node, anchor)); + /// + public override void DidRenderScene(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds) => _didRenderScene.OnNext((renderer, scene, timeInSeconds)); + /// + public override void DidSimulatePhysics(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds) => _didSimulatePhysics.OnNext((renderer, timeInSeconds)); + /// + public override void DidUpdateNode(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor) => _didUpdateNode.OnNext((renderer, node, anchor)); + /// + public override void InterruptionEnded(global::ARKit.ARSession session) => _interruptionEnded.OnNext(session); + /// + public override void Update(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds) => _update.OnNext((renderer, timeInSeconds)); + /// + public override void WasInterrupted(global::ARKit.ARSession session) => _wasInterrupted.OnNext(session); + /// + public override void WillRenderScene(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds) => _willRenderScene.OnNext((renderer, scene, timeInSeconds)); + /// + public override void WillUpdateNode(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNNode node, global::ARKit.ARAnchor anchor) => _willUpdateNode.OnNext((renderer, node, anchor)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class ARSessionDelegateRx : global::ARKit.ARSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARCamera camera)> _cameraDidChangeTrackingState = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARCamera camera)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARAnchor[] anchors)> _didAddAnchors = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARAnchor[] anchors)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARGeoTrackingStatus geoTrackingStatus)> _didChangeGeoTrackingStatus = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARGeoTrackingStatus geoTrackingStatus)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::Foundation.NSError error)> _didFail = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::CoreMedia.CMSampleBuffer audioSampleBuffer)> _didOutputAudioSampleBuffer = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::CoreMedia.CMSampleBuffer audioSampleBuffer)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARCollaborationData data)> _didOutputCollaborationData = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARCollaborationData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARAnchor[] anchors)> _didRemoveAnchors = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARAnchor[] anchors)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARAnchor[] anchors)> _didUpdateAnchors = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARAnchor[] anchors)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARFrame frame)> _didUpdateFrame = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARFrame frame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _interruptionEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _wasInterrupted = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::ARKit.ARCamera camera)> CameraDidChangeTrackingStateObs => _cameraDidChangeTrackingState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::ARKit.ARAnchor[] anchors)> DidAddAnchorsObs => _didAddAnchors; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::ARKit.ARGeoTrackingStatus geoTrackingStatus)> DidChangeGeoTrackingStatusObs => _didChangeGeoTrackingStatus; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::Foundation.NSError error)> DidFailObs => _didFail; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::CoreMedia.CMSampleBuffer audioSampleBuffer)> DidOutputAudioSampleBufferObs => _didOutputAudioSampleBuffer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::ARKit.ARCollaborationData data)> DidOutputCollaborationDataObs => _didOutputCollaborationData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::ARKit.ARAnchor[] anchors)> DidRemoveAnchorsObs => _didRemoveAnchors; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::ARKit.ARAnchor[] anchors)> DidUpdateAnchorsObs => _didUpdateAnchors; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::ARKit.ARFrame frame)> DidUpdateFrameObs => _didUpdateFrame; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable InterruptionEndedObs => _interruptionEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WasInterruptedObs => _wasInterrupted; + /// + public override void CameraDidChangeTrackingState(global::ARKit.ARSession session, global::ARKit.ARCamera camera) => _cameraDidChangeTrackingState.OnNext((session, camera)); + /// + public override void DidAddAnchors(global::ARKit.ARSession session, global::ARKit.ARAnchor[] anchors) => _didAddAnchors.OnNext((session, anchors)); + /// + public override void DidChangeGeoTrackingStatus(global::ARKit.ARSession session, global::ARKit.ARGeoTrackingStatus geoTrackingStatus) => _didChangeGeoTrackingStatus.OnNext((session, geoTrackingStatus)); + /// + public override void DidFail(global::ARKit.ARSession session, global::Foundation.NSError error) => _didFail.OnNext((session, error)); + /// + public override void DidOutputAudioSampleBuffer(global::ARKit.ARSession session, global::CoreMedia.CMSampleBuffer audioSampleBuffer) => _didOutputAudioSampleBuffer.OnNext((session, audioSampleBuffer)); + /// + public override void DidOutputCollaborationData(global::ARKit.ARSession session, global::ARKit.ARCollaborationData data) => _didOutputCollaborationData.OnNext((session, data)); + /// + public override void DidRemoveAnchors(global::ARKit.ARSession session, global::ARKit.ARAnchor[] anchors) => _didRemoveAnchors.OnNext((session, anchors)); + /// + public override void DidUpdateAnchors(global::ARKit.ARSession session, global::ARKit.ARAnchor[] anchors) => _didUpdateAnchors.OnNext((session, anchors)); + /// + public override void DidUpdateFrame(global::ARKit.ARSession session, global::ARKit.ARFrame frame) => _didUpdateFrame.OnNext((session, frame)); + /// + public override void InterruptionEnded(global::ARKit.ARSession session) => _interruptionEnded.OnNext(session); + /// + public override void WasInterrupted(global::ARKit.ARSession session) => _wasInterrupted.OnNext(session); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class ARSKViewDelegateRx : global::ARKit.ARSKViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARCamera camera)> _cameraDidChangeTrackingState = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARCamera camera)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor)> _didAddNode = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARGeoTrackingStatus geoTrackingStatus)> _didChangeGeoTrackingStatus = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARGeoTrackingStatus geoTrackingStatus)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::Foundation.NSError error)> _didFail = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::CoreMedia.CMSampleBuffer audioSampleBuffer)> _didOutputAudioSampleBuffer = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::CoreMedia.CMSampleBuffer audioSampleBuffer)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARCollaborationData data)> _didOutputCollaborationData = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSession session, global::ARKit.ARCollaborationData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor)> _didRemoveNode = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor)> _didUpdateNode = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _interruptionEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _wasInterrupted = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor)> _willUpdateNode = new Pharmacist.Common.SingleAwaitSubject<(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::ARKit.ARCamera camera)> CameraDidChangeTrackingStateObs => _cameraDidChangeTrackingState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor)> DidAddNodeObs => _didAddNode; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::ARKit.ARGeoTrackingStatus geoTrackingStatus)> DidChangeGeoTrackingStatusObs => _didChangeGeoTrackingStatus; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::Foundation.NSError error)> DidFailObs => _didFail; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::CoreMedia.CMSampleBuffer audioSampleBuffer)> DidOutputAudioSampleBufferObs => _didOutputAudioSampleBuffer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSession session, global::ARKit.ARCollaborationData data)> DidOutputCollaborationDataObs => _didOutputCollaborationData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor)> DidRemoveNodeObs => _didRemoveNode; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor)> DidUpdateNodeObs => _didUpdateNode; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable InterruptionEndedObs => _interruptionEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WasInterruptedObs => _wasInterrupted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor)> WillUpdateNodeObs => _willUpdateNode; + /// + public override void CameraDidChangeTrackingState(global::ARKit.ARSession session, global::ARKit.ARCamera camera) => _cameraDidChangeTrackingState.OnNext((session, camera)); + /// + public override void DidAddNode(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor) => _didAddNode.OnNext((view, node, anchor)); + /// + public override void DidChangeGeoTrackingStatus(global::ARKit.ARSession session, global::ARKit.ARGeoTrackingStatus geoTrackingStatus) => _didChangeGeoTrackingStatus.OnNext((session, geoTrackingStatus)); + /// + public override void DidFail(global::ARKit.ARSession session, global::Foundation.NSError error) => _didFail.OnNext((session, error)); + /// + public override void DidOutputAudioSampleBuffer(global::ARKit.ARSession session, global::CoreMedia.CMSampleBuffer audioSampleBuffer) => _didOutputAudioSampleBuffer.OnNext((session, audioSampleBuffer)); + /// + public override void DidOutputCollaborationData(global::ARKit.ARSession session, global::ARKit.ARCollaborationData data) => _didOutputCollaborationData.OnNext((session, data)); + /// + public override void DidRemoveNode(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor) => _didRemoveNode.OnNext((view, node, anchor)); + /// + public override void DidUpdateNode(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor) => _didUpdateNode.OnNext((view, node, anchor)); + /// + public override void InterruptionEnded(global::ARKit.ARSession session) => _interruptionEnded.OnNext(session); + /// + public override void WasInterrupted(global::ARKit.ARSession session) => _wasInterrupted.OnNext(session); + /// + public override void WillUpdateNode(global::ARKit.ARSKView view, global::SpriteKit.SKNode node, global::ARKit.ARAnchor anchor) => _willUpdateNode.OnNext((view, node, anchor)); + } +} + +namespace AuthenticationServices +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class ASAccountAuthenticationModificationControllerDelegateRx : global::AuthenticationServices.ASAccountAuthenticationModificationControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AuthenticationServices.ASAccountAuthenticationModificationController controller, global::AuthenticationServices.ASAccountAuthenticationModificationRequest request, global::Foundation.NSError error)> _didFailRequest = new Pharmacist.Common.SingleAwaitSubject<(global::AuthenticationServices.ASAccountAuthenticationModificationController controller, global::AuthenticationServices.ASAccountAuthenticationModificationRequest request, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AuthenticationServices.ASAccountAuthenticationModificationController controller, global::AuthenticationServices.ASAccountAuthenticationModificationRequest request, global::Foundation.NSDictionary userInfo)> _didSuccessfullyCompleteRequest = new Pharmacist.Common.SingleAwaitSubject<(global::AuthenticationServices.ASAccountAuthenticationModificationController controller, global::AuthenticationServices.ASAccountAuthenticationModificationRequest request, global::Foundation.NSDictionary userInfo)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AuthenticationServices.ASAccountAuthenticationModificationController controller, global::AuthenticationServices.ASAccountAuthenticationModificationRequest request, global::Foundation.NSError error)> DidFailRequestObs => _didFailRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AuthenticationServices.ASAccountAuthenticationModificationController controller, global::AuthenticationServices.ASAccountAuthenticationModificationRequest request, global::Foundation.NSDictionary userInfo)> DidSuccessfullyCompleteRequestObs => _didSuccessfullyCompleteRequest; + /// + public override void DidFailRequest(global::AuthenticationServices.ASAccountAuthenticationModificationController controller, global::AuthenticationServices.ASAccountAuthenticationModificationRequest request, global::Foundation.NSError error) => _didFailRequest.OnNext((controller, request, error)); + /// + public override void DidSuccessfullyCompleteRequest(global::AuthenticationServices.ASAccountAuthenticationModificationController controller, global::AuthenticationServices.ASAccountAuthenticationModificationRequest request, global::Foundation.NSDictionary userInfo) => _didSuccessfullyCompleteRequest.OnNext((controller, request, userInfo)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class ASAuthorizationControllerDelegateRx : global::AuthenticationServices.ASAuthorizationControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AuthenticationServices.ASAuthorizationController controller, global::AuthenticationServices.ASAuthorization authorization)> _didComplete = new Pharmacist.Common.SingleAwaitSubject<(global::AuthenticationServices.ASAuthorizationController controller, global::AuthenticationServices.ASAuthorization authorization)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AuthenticationServices.ASAuthorizationController controller, global::AuthenticationServices.ASAuthorization authorization)> DidCompleteObs => _didComplete; + /// + public override void DidComplete(global::AuthenticationServices.ASAuthorizationController controller, global::AuthenticationServices.ASAuthorization authorization) => _didComplete.OnNext((controller, authorization)); + } +} + +namespace AutomaticAssessmentConfiguration +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class AEAssessmentSessionDelegateRx : global::AutomaticAssessmentConfiguration.AEAssessmentSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBegin = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEnd = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error)> _failedToBegin = new Pharmacist.Common.SingleAwaitSubject<(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error)> _wasInterrupted = new Pharmacist.Common.SingleAwaitSubject<(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBeginObs => _didBegin; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndObs => _didEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error)> FailedToBeginObs => _failedToBegin; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error)> WasInterruptedObs => _wasInterrupted; + /// + public override void DidBegin(global::AutomaticAssessmentConfiguration.AEAssessmentSession session) => _didBegin.OnNext(session); + /// + public override void DidEnd(global::AutomaticAssessmentConfiguration.AEAssessmentSession session) => _didEnd.OnNext(session); + /// + public override void FailedToBegin(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error) => _failedToBegin.OnNext((session, error)); + /// + public override void WasInterrupted(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error) => _wasInterrupted.OnNext((session, error)); + } +} + +namespace AVFoundation +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVAssetDownloadDelegateRx : global::AVFoundation.AVAssetDownloadDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::AVFoundation.AVAggregateAssetDownloadTask aggregateAssetDownloadTask, global::AVFoundation.AVMediaSelection mediaSelection)> _didCompleteForMediaSelection = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::AVFoundation.AVAggregateAssetDownloadTask aggregateAssetDownloadTask, global::AVFoundation.AVMediaSelection mediaSelection)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error)> _didCompleteWithError = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics)> _didFinishCollectingMetrics = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::AVFoundation.AVAssetDownloadTask assetDownloadTask, global::Foundation.NSUrl location)> _didFinishDownloadingToUrl = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::AVFoundation.AVAssetDownloadTask assetDownloadTask, global::Foundation.NSUrl location)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::AVFoundation.AVAggregateAssetDownloadTask aggregateAssetDownloadTask, global::CoreMedia.CMTimeRange timeRange, global::Foundation.NSValue[] loadedTimeRanges, global::CoreMedia.CMTimeRange timeRangeExpectedToLoad, global::AVFoundation.AVMediaSelection mediaSelection)> _didLoadTimeRange = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::AVFoundation.AVAggregateAssetDownloadTask aggregateAssetDownloadTask, global::CoreMedia.CMTimeRange timeRange, global::Foundation.NSValue[] loadedTimeRanges, global::CoreMedia.CMTimeRange timeRangeExpectedToLoad, global::AVFoundation.AVMediaSelection mediaSelection)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> _didReceiveChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::AVFoundation.AVAssetDownloadTask assetDownloadTask, global::AVFoundation.AVMediaSelection resolvedMediaSelection)> _didResolveMediaSelection = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::AVFoundation.AVAssetDownloadTask assetDownloadTask, global::AVFoundation.AVMediaSelection resolvedMediaSelection)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend)> _didSendBodyData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler)> _needNewBodyStream = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task)> _taskIsWaitingForConnectivity = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler)> _willBeginDelayedRequest = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::AVFoundation.AVAggregateAssetDownloadTask aggregateAssetDownloadTask, global::Foundation.NSUrl location)> _willDownloadToUrl = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::AVFoundation.AVAggregateAssetDownloadTask aggregateAssetDownloadTask, global::Foundation.NSUrl location)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler)> _willPerformHttpRedirection = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::AVFoundation.AVAggregateAssetDownloadTask aggregateAssetDownloadTask, global::AVFoundation.AVMediaSelection mediaSelection)> DidCompleteForMediaSelectionObs => _didCompleteForMediaSelection; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error)> DidCompleteWithErrorObs => _didCompleteWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics)> DidFinishCollectingMetricsObs => _didFinishCollectingMetrics; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::AVFoundation.AVAssetDownloadTask assetDownloadTask, global::Foundation.NSUrl location)> DidFinishDownloadingToUrlObs => _didFinishDownloadingToUrl; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::AVFoundation.AVAggregateAssetDownloadTask aggregateAssetDownloadTask, global::CoreMedia.CMTimeRange timeRange, global::Foundation.NSValue[] loadedTimeRanges, global::CoreMedia.CMTimeRange timeRangeExpectedToLoad, global::AVFoundation.AVMediaSelection mediaSelection)> DidLoadTimeRangeObs => _didLoadTimeRange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> DidReceiveChallengeObs => _didReceiveChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::AVFoundation.AVAssetDownloadTask assetDownloadTask, global::AVFoundation.AVMediaSelection resolvedMediaSelection)> DidResolveMediaSelectionObs => _didResolveMediaSelection; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend)> DidSendBodyDataObs => _didSendBodyData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler)> NeedNewBodyStreamObs => _needNewBodyStream; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task)> TaskIsWaitingForConnectivityObs => _taskIsWaitingForConnectivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler)> WillBeginDelayedRequestObs => _willBeginDelayedRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::AVFoundation.AVAggregateAssetDownloadTask aggregateAssetDownloadTask, global::Foundation.NSUrl location)> WillDownloadToUrlObs => _willDownloadToUrl; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler)> WillPerformHttpRedirectionObs => _willPerformHttpRedirection; + /// + public override void DidCompleteForMediaSelection(global::Foundation.NSUrlSession session, global::AVFoundation.AVAggregateAssetDownloadTask aggregateAssetDownloadTask, global::AVFoundation.AVMediaSelection mediaSelection) => _didCompleteForMediaSelection.OnNext((session, aggregateAssetDownloadTask, mediaSelection)); + /// + public override void DidCompleteWithError(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error) => _didCompleteWithError.OnNext((session, task, error)); + /// + public override void DidFinishCollectingMetrics(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics) => _didFinishCollectingMetrics.OnNext((session, task, metrics)); + /// + public override void DidFinishDownloadingToUrl(global::Foundation.NSUrlSession session, global::AVFoundation.AVAssetDownloadTask assetDownloadTask, global::Foundation.NSUrl location) => _didFinishDownloadingToUrl.OnNext((session, assetDownloadTask, location)); + /// + public override void DidLoadTimeRange(global::Foundation.NSUrlSession session, global::AVFoundation.AVAggregateAssetDownloadTask aggregateAssetDownloadTask, global::CoreMedia.CMTimeRange timeRange, global::Foundation.NSValue[] loadedTimeRanges, global::CoreMedia.CMTimeRange timeRangeExpectedToLoad, global::AVFoundation.AVMediaSelection mediaSelection) => _didLoadTimeRange.OnNext((session, aggregateAssetDownloadTask, timeRange, loadedTimeRanges, timeRangeExpectedToLoad, mediaSelection)); + /// + public override void DidReceiveChallenge(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler) => _didReceiveChallenge.OnNext((session, task, challenge, completionHandler)); + /// + public override void DidResolveMediaSelection(global::Foundation.NSUrlSession session, global::AVFoundation.AVAssetDownloadTask assetDownloadTask, global::AVFoundation.AVMediaSelection resolvedMediaSelection) => _didResolveMediaSelection.OnNext((session, assetDownloadTask, resolvedMediaSelection)); + /// + public override void DidSendBodyData(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend) => _didSendBodyData.OnNext((session, task, bytesSent, totalBytesSent, totalBytesExpectedToSend)); + /// + public override void NeedNewBodyStream(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler) => _needNewBodyStream.OnNext((session, task, completionHandler)); + /// + public override void TaskIsWaitingForConnectivity(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task) => _taskIsWaitingForConnectivity.OnNext((session, task)); + /// + public override void WillBeginDelayedRequest(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler) => _willBeginDelayedRequest.OnNext((session, task, request, completionHandler)); + /// + public override void WillDownloadToUrl(global::Foundation.NSUrlSession session, global::AVFoundation.AVAggregateAssetDownloadTask aggregateAssetDownloadTask, global::Foundation.NSUrl location) => _willDownloadToUrl.OnNext((session, aggregateAssetDownloadTask, location)); + /// + public override void WillPerformHttpRedirection(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler) => _willPerformHttpRedirection.OnNext((session, task, response, newRequest, completionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class AVAssetResourceLoaderDelegateRx : global::AVFoundation.AVAssetResourceLoaderDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::Foundation.NSUrlAuthenticationChallenge authenticationChallenge)> _didCancelAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::Foundation.NSUrlAuthenticationChallenge authenticationChallenge)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::AVFoundation.AVAssetResourceLoadingRequest loadingRequest)> _didCancelLoadingRequest = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::AVFoundation.AVAssetResourceLoadingRequest loadingRequest)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::Foundation.NSUrlAuthenticationChallenge authenticationChallenge)> DidCancelAuthenticationChallengeObs => _didCancelAuthenticationChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::AVFoundation.AVAssetResourceLoadingRequest loadingRequest)> DidCancelLoadingRequestObs => _didCancelLoadingRequest; + /// + public override void DidCancelAuthenticationChallenge(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::Foundation.NSUrlAuthenticationChallenge authenticationChallenge) => _didCancelAuthenticationChallenge.OnNext((resourceLoader, authenticationChallenge)); + /// + public override void DidCancelLoadingRequest(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::AVFoundation.AVAssetResourceLoadingRequest loadingRequest) => _didCancelLoadingRequest.OnNext((resourceLoader, loadingRequest)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVAssetWriterDelegateRx : global::AVFoundation.AVAssetWriterDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAssetWriter writer, global::Foundation.NSData segmentData, global::AVFoundation.AVAssetSegmentType segmentType, global::AVFoundation.AVAssetSegmentReport segmentReport)> _didOutputSegmentData = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAssetWriter writer, global::Foundation.NSData segmentData, global::AVFoundation.AVAssetSegmentType segmentType, global::AVFoundation.AVAssetSegmentReport segmentReport)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAssetWriter writer, global::Foundation.NSData segmentData, global::AVFoundation.AVAssetSegmentType segmentType, global::AVFoundation.AVAssetSegmentReport segmentReport)> DidOutputSegmentDataObs => _didOutputSegmentData; + /// + public override void DidOutputSegmentData(global::AVFoundation.AVAssetWriter writer, global::Foundation.NSData segmentData, global::AVFoundation.AVAssetSegmentType segmentType, global::AVFoundation.AVAssetSegmentReport segmentReport) => _didOutputSegmentData.OnNext((writer, segmentData, segmentType, segmentReport)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVAudioPlayerDelegateRx : global::AVFoundation.AVAudioPlayerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _beginInterruption = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, global::Foundation.NSError error)> _decoderError = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, global::AVFoundation.AVAudioSessionInterruptionFlags flags)> _endInterruption = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, global::AVFoundation.AVAudioSessionInterruptionFlags flags)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, bool flag)> _finishedPlaying = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, bool flag)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable BeginInterruptionObs => _beginInterruption; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioPlayer player, global::Foundation.NSError error)> DecoderErrorObs => _decoderError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioPlayer player, global::AVFoundation.AVAudioSessionInterruptionFlags flags)> EndInterruptionObs => _endInterruption; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioPlayer player, bool flag)> FinishedPlayingObs => _finishedPlaying; + /// + public override void BeginInterruption(global::AVFoundation.AVAudioPlayer player) => _beginInterruption.OnNext(player); + /// + public override void DecoderError(global::AVFoundation.AVAudioPlayer player, global::Foundation.NSError error) => _decoderError.OnNext((player, error)); + /// + public override void EndInterruption(global::AVFoundation.AVAudioPlayer player, global::AVFoundation.AVAudioSessionInterruptionFlags flags) => _endInterruption.OnNext((player, flags)); + /// + public override void FinishedPlaying(global::AVFoundation.AVAudioPlayer player, bool flag) => _finishedPlaying.OnNext((player, flag)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVAudioRecorderDelegateRx : global::AVFoundation.AVAudioRecorderDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _beginInterruption = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, global::Foundation.NSError error)> _encoderError = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, global::AVFoundation.AVAudioSessionInterruptionFlags flags)> _endInterruption = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, global::AVFoundation.AVAudioSessionInterruptionFlags flags)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, bool flag)> _finishedRecording = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, bool flag)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable BeginInterruptionObs => _beginInterruption; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioRecorder recorder, global::Foundation.NSError error)> EncoderErrorObs => _encoderError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioRecorder recorder, global::AVFoundation.AVAudioSessionInterruptionFlags flags)> EndInterruptionObs => _endInterruption; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioRecorder recorder, bool flag)> FinishedRecordingObs => _finishedRecording; + /// + public override void BeginInterruption(global::AVFoundation.AVAudioRecorder recorder) => _beginInterruption.OnNext(recorder); + /// + public override void EncoderError(global::AVFoundation.AVAudioRecorder recorder, global::Foundation.NSError error) => _encoderError.OnNext((recorder, error)); + /// + public override void EndInterruption(global::AVFoundation.AVAudioRecorder recorder, global::AVFoundation.AVAudioSessionInterruptionFlags flags) => _endInterruption.OnNext((recorder, flags)); + /// + public override void FinishedRecording(global::AVFoundation.AVAudioRecorder recorder, bool flag) => _finishedRecording.OnNext((recorder, flag)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVAudioSessionDelegateRx : global::AVFoundation.AVAudioSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _beginInterruption = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _endInterruption = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _inputIsAvailableChanged = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable BeginInterruptionObs => _beginInterruption; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable EndInterruptionObs => _endInterruption; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable InputIsAvailableChangedObs => _inputIsAvailableChanged; + /// + public override void BeginInterruption() => _beginInterruption.OnNext(global::System.Reactive.Unit.Default); + /// + public override void EndInterruption(global::AVFoundation.AVAudioSessionInterruptionFlags flags) => _endInterruption.OnNext(flags); + /// + public override void InputIsAvailableChanged(bool isInputAvailable) => _inputIsAvailableChanged.OnNext(isInputAvailable); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVCaptureAudioDataOutputSampleBufferDelegateRx : global::AVFoundation.AVCaptureAudioDataOutputSampleBufferDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> _didDropSampleBuffer = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> _didOutputSampleBuffer = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + [global::System.ObsoleteAttribute("This member only exists for 'AVCaptureVideoDataOutputSampleBufferDelegate'.", false)] + public global::System.IObservable<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> DidDropSampleBufferObs => _didDropSampleBuffer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> DidOutputSampleBufferObs => _didOutputSampleBuffer; + /// + [global::System.ObsoleteAttribute("This member only exists for 'AVCaptureVideoDataOutputSampleBufferDelegate'.", false)] + public override void DidDropSampleBuffer(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection) => _didDropSampleBuffer.OnNext((captureOutput, sampleBuffer, connection)); + /// + public override void DidOutputSampleBuffer(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection) => _didOutputSampleBuffer.OnNext((captureOutput, sampleBuffer, connection)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class AVCaptureDataOutputSynchronizerDelegateRx : global::AVFoundation.AVCaptureDataOutputSynchronizerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureDataOutputSynchronizer synchronizer, global::AVFoundation.AVCaptureSynchronizedDataCollection synchronizedDataCollection)> _didOutputSynchronizedDataCollection = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureDataOutputSynchronizer synchronizer, global::AVFoundation.AVCaptureSynchronizedDataCollection synchronizedDataCollection)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureDataOutputSynchronizer synchronizer, global::AVFoundation.AVCaptureSynchronizedDataCollection synchronizedDataCollection)> DidOutputSynchronizedDataCollectionObs => _didOutputSynchronizedDataCollection; + /// + public override void DidOutputSynchronizedDataCollection(global::AVFoundation.AVCaptureDataOutputSynchronizer synchronizer, global::AVFoundation.AVCaptureSynchronizedDataCollection synchronizedDataCollection) => _didOutputSynchronizedDataCollection.OnNext((synchronizer, synchronizedDataCollection)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVCaptureDepthDataOutputDelegateRx : global::AVFoundation.AVCaptureDepthDataOutputDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureDepthDataOutput output, global::AVFoundation.AVDepthData depthData, global::CoreMedia.CMTime timestamp, global::AVFoundation.AVCaptureConnection connection, global::AVFoundation.AVCaptureOutputDataDroppedReason reason)> _didDropDepthData = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureDepthDataOutput output, global::AVFoundation.AVDepthData depthData, global::CoreMedia.CMTime timestamp, global::AVFoundation.AVCaptureConnection connection, global::AVFoundation.AVCaptureOutputDataDroppedReason reason)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureDepthDataOutput output, global::AVFoundation.AVDepthData depthData, global::CoreMedia.CMTime timestamp, global::AVFoundation.AVCaptureConnection connection)> _didOutputDepthData = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureDepthDataOutput output, global::AVFoundation.AVDepthData depthData, global::CoreMedia.CMTime timestamp, global::AVFoundation.AVCaptureConnection connection)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureDepthDataOutput output, global::AVFoundation.AVDepthData depthData, global::CoreMedia.CMTime timestamp, global::AVFoundation.AVCaptureConnection connection, global::AVFoundation.AVCaptureOutputDataDroppedReason reason)> DidDropDepthDataObs => _didDropDepthData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureDepthDataOutput output, global::AVFoundation.AVDepthData depthData, global::CoreMedia.CMTime timestamp, global::AVFoundation.AVCaptureConnection connection)> DidOutputDepthDataObs => _didOutputDepthData; + /// + public override void DidDropDepthData(global::AVFoundation.AVCaptureDepthDataOutput output, global::AVFoundation.AVDepthData depthData, global::CoreMedia.CMTime timestamp, global::AVFoundation.AVCaptureConnection connection, global::AVFoundation.AVCaptureOutputDataDroppedReason reason) => _didDropDepthData.OnNext((output, depthData, timestamp, connection, reason)); + /// + public override void DidOutputDepthData(global::AVFoundation.AVCaptureDepthDataOutput output, global::AVFoundation.AVDepthData depthData, global::CoreMedia.CMTime timestamp, global::AVFoundation.AVCaptureConnection connection) => _didOutputDepthData.OnNext((output, depthData, timestamp, connection)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class AVCaptureFileOutputRecordingDelegateRx : global::AVFoundation.AVCaptureFileOutputRecordingDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections)> _didStartRecording = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections, global::Foundation.NSError error)> _finishedRecording = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections)> DidStartRecordingObs => _didStartRecording; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections, global::Foundation.NSError error)> FinishedRecordingObs => _finishedRecording; + /// + public override void DidStartRecording(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections) => _didStartRecording.OnNext((captureOutput, outputFileUrl, connections)); + /// + public override void FinishedRecording(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections, global::Foundation.NSError error) => _finishedRecording.OnNext((captureOutput, outputFileUrl, connections, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVCaptureMetadataOutputObjectsDelegateRx : global::AVFoundation.AVCaptureMetadataOutputObjectsDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureMetadataOutput captureOutput, global::AVFoundation.AVMetadataObject[] metadataObjects, global::AVFoundation.AVCaptureConnection connection)> _didOutputMetadataObjects = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureMetadataOutput captureOutput, global::AVFoundation.AVMetadataObject[] metadataObjects, global::AVFoundation.AVCaptureConnection connection)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureMetadataOutput captureOutput, global::AVFoundation.AVMetadataObject[] metadataObjects, global::AVFoundation.AVCaptureConnection connection)> DidOutputMetadataObjectsObs => _didOutputMetadataObjects; + /// + public override void DidOutputMetadataObjects(global::AVFoundation.AVCaptureMetadataOutput captureOutput, global::AVFoundation.AVMetadataObject[] metadataObjects, global::AVFoundation.AVCaptureConnection connection) => _didOutputMetadataObjects.OnNext((captureOutput, metadataObjects, connection)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVCapturePhotoCaptureDelegateRx : global::AVFoundation.AVCapturePhotoCaptureDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)> _didCapturePhoto = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::Foundation.NSError error)> _didFinishCapture = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::CoreMedia.CMTime duration, global::CoreMedia.CMTime photoDisplayTime, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::Foundation.NSError error)> _didFinishProcessingLivePhotoMovie = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::CoreMedia.CMTime duration, global::CoreMedia.CMTime photoDisplayTime, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::CoreMedia.CMSampleBuffer photoSampleBuffer, global::CoreMedia.CMSampleBuffer previewPhotoSampleBuffer, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::AVFoundation.AVCaptureBracketedStillImageSettings bracketSettings, global::Foundation.NSError error)> _didFinishProcessingPhoto = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::CoreMedia.CMSampleBuffer photoSampleBuffer, global::CoreMedia.CMSampleBuffer previewPhotoSampleBuffer, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::AVFoundation.AVCaptureBracketedStillImageSettings bracketSettings, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::CoreMedia.CMSampleBuffer rawSampleBuffer, global::CoreMedia.CMSampleBuffer previewPhotoSampleBuffer, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::AVFoundation.AVCaptureBracketedStillImageSettings bracketSettings, global::Foundation.NSError error)> _didFinishProcessingRawPhoto = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::CoreMedia.CMSampleBuffer rawSampleBuffer, global::CoreMedia.CMSampleBuffer previewPhotoSampleBuffer, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::AVFoundation.AVCaptureBracketedStillImageSettings bracketSettings, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)> _didFinishRecordingLivePhotoMovie = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)> _willBeginCapture = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)> _willCapturePhoto = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)> DidCapturePhotoObs => _didCapturePhoto; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::Foundation.NSError error)> DidFinishCaptureObs => _didFinishCapture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::CoreMedia.CMTime duration, global::CoreMedia.CMTime photoDisplayTime, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::Foundation.NSError error)> DidFinishProcessingLivePhotoMovieObs => _didFinishProcessingLivePhotoMovie; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::CoreMedia.CMSampleBuffer photoSampleBuffer, global::CoreMedia.CMSampleBuffer previewPhotoSampleBuffer, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::AVFoundation.AVCaptureBracketedStillImageSettings bracketSettings, global::Foundation.NSError error)> DidFinishProcessingPhotoObs => _didFinishProcessingPhoto; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::CoreMedia.CMSampleBuffer rawSampleBuffer, global::CoreMedia.CMSampleBuffer previewPhotoSampleBuffer, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::AVFoundation.AVCaptureBracketedStillImageSettings bracketSettings, global::Foundation.NSError error)> DidFinishProcessingRawPhotoObs => _didFinishProcessingRawPhoto; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)> DidFinishRecordingLivePhotoMovieObs => _didFinishRecordingLivePhotoMovie; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)> WillBeginCaptureObs => _willBeginCapture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)> WillCapturePhotoObs => _willCapturePhoto; + /// + public override void DidCapturePhoto(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings) => _didCapturePhoto.OnNext((captureOutput, resolvedSettings)); + /// + public override void DidFinishCapture(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::Foundation.NSError error) => _didFinishCapture.OnNext((captureOutput, resolvedSettings, error)); + /// + public override void DidFinishProcessingLivePhotoMovie(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::CoreMedia.CMTime duration, global::CoreMedia.CMTime photoDisplayTime, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::Foundation.NSError error) => _didFinishProcessingLivePhotoMovie.OnNext((captureOutput, outputFileUrl, duration, photoDisplayTime, resolvedSettings, error)); + /// + public override void DidFinishProcessingPhoto(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::CoreMedia.CMSampleBuffer photoSampleBuffer, global::CoreMedia.CMSampleBuffer previewPhotoSampleBuffer, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::AVFoundation.AVCaptureBracketedStillImageSettings bracketSettings, global::Foundation.NSError error) => _didFinishProcessingPhoto.OnNext((captureOutput, photoSampleBuffer, previewPhotoSampleBuffer, resolvedSettings, bracketSettings, error)); + /// + public override void DidFinishProcessingRawPhoto(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::CoreMedia.CMSampleBuffer rawSampleBuffer, global::CoreMedia.CMSampleBuffer previewPhotoSampleBuffer, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::AVFoundation.AVCaptureBracketedStillImageSettings bracketSettings, global::Foundation.NSError error) => _didFinishProcessingRawPhoto.OnNext((captureOutput, rawSampleBuffer, previewPhotoSampleBuffer, resolvedSettings, bracketSettings, error)); + /// + public override void DidFinishRecordingLivePhotoMovie(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings) => _didFinishRecordingLivePhotoMovie.OnNext((captureOutput, outputFileUrl, resolvedSettings)); + /// + public override void WillBeginCapture(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings) => _willBeginCapture.OnNext((captureOutput, resolvedSettings)); + /// + public override void WillCapturePhoto(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings) => _willCapturePhoto.OnNext((captureOutput, resolvedSettings)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVCaptureVideoDataOutputSampleBufferDelegateRx : global::AVFoundation.AVCaptureVideoDataOutputSampleBufferDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> _didDropSampleBuffer = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> _didOutputSampleBuffer = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> DidDropSampleBufferObs => _didDropSampleBuffer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> DidOutputSampleBufferObs => _didOutputSampleBuffer; + /// + public override void DidDropSampleBuffer(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection) => _didDropSampleBuffer.OnNext((captureOutput, sampleBuffer, connection)); + /// + public override void DidOutputSampleBuffer(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection) => _didOutputSampleBuffer.OnNext((captureOutput, sampleBuffer, connection)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class AVContentKeySessionDelegateRx : global::AVFoundation.AVContentKeySessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest, global::Foundation.NSError err)> _didFail = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest, global::Foundation.NSError err)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didGenerateExpiredSessionReport = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> _didProvideContentKeyRequest = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVPersistableContentKeyRequest keyRequest)> _didProvidePersistableContentKeyRequest = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVPersistableContentKeyRequest keyRequest)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> _didProvideRenewingContentKeyRequest = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> _didSucceed = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::Foundation.NSData persistableContentKey, global::Foundation.NSObject keyIdentifier)> _didUpdate = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::Foundation.NSData persistableContentKey, global::Foundation.NSObject keyIdentifier)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeObs => _didChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest, global::Foundation.NSError err)> DidFailObs => _didFail; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidGenerateExpiredSessionReportObs => _didGenerateExpiredSessionReport; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> DidProvideContentKeyRequestObs => _didProvideContentKeyRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVPersistableContentKeyRequest keyRequest)> DidProvidePersistableContentKeyRequestObs => _didProvidePersistableContentKeyRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> DidProvideRenewingContentKeyRequestObs => _didProvideRenewingContentKeyRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> DidSucceedObs => _didSucceed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::Foundation.NSData persistableContentKey, global::Foundation.NSObject keyIdentifier)> DidUpdateObs => _didUpdate; + /// + public override void DidChange(global::AVFoundation.AVContentKeySession session) => _didChange.OnNext(session); + /// + public override void DidFail(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest, global::Foundation.NSError err) => _didFail.OnNext((session, keyRequest, err)); + /// + public override void DidGenerateExpiredSessionReport(global::AVFoundation.AVContentKeySession session) => _didGenerateExpiredSessionReport.OnNext(session); + /// + public override void DidProvideContentKeyRequest(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest) => _didProvideContentKeyRequest.OnNext((session, keyRequest)); + /// + public override void DidProvidePersistableContentKeyRequest(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVPersistableContentKeyRequest keyRequest) => _didProvidePersistableContentKeyRequest.OnNext((session, keyRequest)); + /// + public override void DidProvideRenewingContentKeyRequest(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest) => _didProvideRenewingContentKeyRequest.OnNext((session, keyRequest)); + /// + public override void DidSucceed(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest) => _didSucceed.OnNext((session, keyRequest)); + /// + public override void DidUpdate(global::AVFoundation.AVContentKeySession session, global::Foundation.NSData persistableContentKey, global::Foundation.NSObject keyIdentifier) => _didUpdate.OnNext((session, persistableContentKey, keyIdentifier)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class AVPlayerItemMetadataCollectorPushDelegateRx : global::AVFoundation.AVPlayerItemMetadataCollectorPushDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVPlayerItemMetadataCollector metadataCollector, global::AVFoundation.AVDateRangeMetadataGroup[] metadataGroups, global::Foundation.NSIndexSet indexesOfNewGroups, global::Foundation.NSIndexSet indexesOfModifiedGroups)> _didCollectDateRange = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVPlayerItemMetadataCollector metadataCollector, global::AVFoundation.AVDateRangeMetadataGroup[] metadataGroups, global::Foundation.NSIndexSet indexesOfNewGroups, global::Foundation.NSIndexSet indexesOfModifiedGroups)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVPlayerItemMetadataCollector metadataCollector, global::AVFoundation.AVDateRangeMetadataGroup[] metadataGroups, global::Foundation.NSIndexSet indexesOfNewGroups, global::Foundation.NSIndexSet indexesOfModifiedGroups)> DidCollectDateRangeObs => _didCollectDateRange; + /// + public override void DidCollectDateRange(global::AVFoundation.AVPlayerItemMetadataCollector metadataCollector, global::AVFoundation.AVDateRangeMetadataGroup[] metadataGroups, global::Foundation.NSIndexSet indexesOfNewGroups, global::Foundation.NSIndexSet indexesOfModifiedGroups) => _didCollectDateRange.OnNext((metadataCollector, metadataGroups, indexesOfNewGroups, indexesOfModifiedGroups)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVPlayerItemMetadataOutputPushDelegateRx : global::AVFoundation.AVPlayerItemMetadataOutputPushDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVPlayerItemMetadataOutput output, global::AVFoundation.AVTimedMetadataGroup[] groups, global::AVFoundation.AVPlayerItemTrack track)> _didOutputTimedMetadataGroups = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVPlayerItemMetadataOutput output, global::AVFoundation.AVTimedMetadataGroup[] groups, global::AVFoundation.AVPlayerItemTrack track)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _outputSequenceWasFlushed = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVPlayerItemMetadataOutput output, global::AVFoundation.AVTimedMetadataGroup[] groups, global::AVFoundation.AVPlayerItemTrack track)> DidOutputTimedMetadataGroupsObs => _didOutputTimedMetadataGroups; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OutputSequenceWasFlushedObs => _outputSequenceWasFlushed; + /// + public override void DidOutputTimedMetadataGroups(global::AVFoundation.AVPlayerItemMetadataOutput output, global::AVFoundation.AVTimedMetadataGroup[] groups, global::AVFoundation.AVPlayerItemTrack track) => _didOutputTimedMetadataGroups.OnNext((output, groups, track)); + /// + public override void OutputSequenceWasFlushed(global::AVFoundation.AVPlayerItemOutput output) => _outputSequenceWasFlushed.OnNext(output); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVPlayerItemOutputPullDelegateRx : global::AVFoundation.AVPlayerItemOutputPullDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _outputMediaDataWillChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _outputSequenceWasFlushed = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OutputMediaDataWillChangeObs => _outputMediaDataWillChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OutputSequenceWasFlushedObs => _outputSequenceWasFlushed; + /// + public override void OutputMediaDataWillChange(global::AVFoundation.AVPlayerItemOutput sender) => _outputMediaDataWillChange.OnNext(sender); + /// + public override void OutputSequenceWasFlushed(global::AVFoundation.AVPlayerItemOutput output) => _outputSequenceWasFlushed.OnNext(output); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVPlayerItemOutputPushDelegateRx : global::AVFoundation.AVPlayerItemOutputPushDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _outputSequenceWasFlushed = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OutputSequenceWasFlushedObs => _outputSequenceWasFlushed; + /// + public override void OutputSequenceWasFlushed(global::AVFoundation.AVPlayerItemOutput output) => _outputSequenceWasFlushed.OnNext(output); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVSpeechSynthesizerDelegateRx : global::AVFoundation.AVSpeechSynthesizerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> _didCancelSpeechUtterance = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> _didContinueSpeechUtterance = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> _didFinishSpeechUtterance = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> _didPauseSpeechUtterance = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> _didStartSpeechUtterance = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::Foundation.NSRange characterRange, global::AVFoundation.AVSpeechUtterance utterance)> _willSpeakRangeOfSpeechString = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::Foundation.NSRange characterRange, global::AVFoundation.AVSpeechUtterance utterance)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> DidCancelSpeechUtteranceObs => _didCancelSpeechUtterance; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> DidContinueSpeechUtteranceObs => _didContinueSpeechUtterance; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> DidFinishSpeechUtteranceObs => _didFinishSpeechUtterance; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> DidPauseSpeechUtteranceObs => _didPauseSpeechUtterance; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> DidStartSpeechUtteranceObs => _didStartSpeechUtterance; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::Foundation.NSRange characterRange, global::AVFoundation.AVSpeechUtterance utterance)> WillSpeakRangeOfSpeechStringObs => _willSpeakRangeOfSpeechString; + /// + public override void DidCancelSpeechUtterance(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance) => _didCancelSpeechUtterance.OnNext((synthesizer, utterance)); + /// + public override void DidContinueSpeechUtterance(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance) => _didContinueSpeechUtterance.OnNext((synthesizer, utterance)); + /// + public override void DidFinishSpeechUtterance(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance) => _didFinishSpeechUtterance.OnNext((synthesizer, utterance)); + /// + public override void DidPauseSpeechUtterance(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance) => _didPauseSpeechUtterance.OnNext((synthesizer, utterance)); + /// + public override void DidStartSpeechUtterance(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance) => _didStartSpeechUtterance.OnNext((synthesizer, utterance)); + /// + public override void WillSpeakRangeOfSpeechString(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::Foundation.NSRange characterRange, global::AVFoundation.AVSpeechUtterance utterance) => _willSpeakRangeOfSpeechString.OnNext((synthesizer, characterRange, utterance)); + } +} + +namespace AVKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVPictureInPictureControllerDelegateRx : global::AVKit.AVPictureInPictureControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didStartPictureInPicture = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didStopPictureInPicture = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPictureInPictureController pictureInPictureController, global::Foundation.NSError error)> _failedToStartPictureInPicture = new Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPictureInPictureController pictureInPictureController, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPictureInPictureController pictureInPictureController, global::System.Action completionHandler)> _restoreUserInterfaceForPictureInPicture = new Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPictureInPictureController pictureInPictureController, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStartPictureInPicture = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStopPictureInPicture = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidStartPictureInPictureObs => _didStartPictureInPicture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidStopPictureInPictureObs => _didStopPictureInPicture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVKit.AVPictureInPictureController pictureInPictureController, global::Foundation.NSError error)> FailedToStartPictureInPictureObs => _failedToStartPictureInPicture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVKit.AVPictureInPictureController pictureInPictureController, global::System.Action completionHandler)> RestoreUserInterfaceForPictureInPictureObs => _restoreUserInterfaceForPictureInPicture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStartPictureInPictureObs => _willStartPictureInPicture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStopPictureInPictureObs => _willStopPictureInPicture; + /// + public override void DidStartPictureInPicture(global::AVKit.AVPictureInPictureController pictureInPictureController) => _didStartPictureInPicture.OnNext(pictureInPictureController); + /// + public override void DidStopPictureInPicture(global::AVKit.AVPictureInPictureController pictureInPictureController) => _didStopPictureInPicture.OnNext(pictureInPictureController); + /// + public override void FailedToStartPictureInPicture(global::AVKit.AVPictureInPictureController pictureInPictureController, global::Foundation.NSError error) => _failedToStartPictureInPicture.OnNext((pictureInPictureController, error)); + /// + public override void RestoreUserInterfaceForPictureInPicture(global::AVKit.AVPictureInPictureController pictureInPictureController, global::System.Action completionHandler) => _restoreUserInterfaceForPictureInPicture.OnNext((pictureInPictureController, completionHandler)); + /// + public override void WillStartPictureInPicture(global::AVKit.AVPictureInPictureController pictureInPictureController) => _willStartPictureInPicture.OnNext(pictureInPictureController); + /// + public override void WillStopPictureInPicture(global::AVKit.AVPictureInPictureController pictureInPictureController) => _willStopPictureInPicture.OnNext(pictureInPictureController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVPlayerViewControllerDelegateRx : global::AVKit.AVPlayerViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didStartPictureInPicture = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didStopPictureInPicture = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPlayerViewController playerViewController, global::Foundation.NSError error)> _failedToStartPictureInPicture = new Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPlayerViewController playerViewController, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPlayerViewController playerViewController, global::System.Action completionHandler)> _restoreUserInterfaceForPictureInPicture = new Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPlayerViewController playerViewController, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPlayerViewController playerViewController, global::UIKit.IUIViewControllerTransitionCoordinator coordinator)> _willBeginFullScreenPresentation = new Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPlayerViewController playerViewController, global::UIKit.IUIViewControllerTransitionCoordinator coordinator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPlayerViewController playerViewController, global::UIKit.IUIViewControllerTransitionCoordinator coordinator)> _willEndFullScreenPresentation = new Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPlayerViewController playerViewController, global::UIKit.IUIViewControllerTransitionCoordinator coordinator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStartPictureInPicture = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStopPictureInPicture = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidStartPictureInPictureObs => _didStartPictureInPicture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidStopPictureInPictureObs => _didStopPictureInPicture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVKit.AVPlayerViewController playerViewController, global::Foundation.NSError error)> FailedToStartPictureInPictureObs => _failedToStartPictureInPicture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVKit.AVPlayerViewController playerViewController, global::System.Action completionHandler)> RestoreUserInterfaceForPictureInPictureObs => _restoreUserInterfaceForPictureInPicture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVKit.AVPlayerViewController playerViewController, global::UIKit.IUIViewControllerTransitionCoordinator coordinator)> WillBeginFullScreenPresentationObs => _willBeginFullScreenPresentation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVKit.AVPlayerViewController playerViewController, global::UIKit.IUIViewControllerTransitionCoordinator coordinator)> WillEndFullScreenPresentationObs => _willEndFullScreenPresentation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStartPictureInPictureObs => _willStartPictureInPicture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStopPictureInPictureObs => _willStopPictureInPicture; + /// + public override void DidStartPictureInPicture(global::AVKit.AVPlayerViewController playerViewController) => _didStartPictureInPicture.OnNext(playerViewController); + /// + public override void DidStopPictureInPicture(global::AVKit.AVPlayerViewController playerViewController) => _didStopPictureInPicture.OnNext(playerViewController); + /// + public override void FailedToStartPictureInPicture(global::AVKit.AVPlayerViewController playerViewController, global::Foundation.NSError error) => _failedToStartPictureInPicture.OnNext((playerViewController, error)); + /// + public override void RestoreUserInterfaceForPictureInPicture(global::AVKit.AVPlayerViewController playerViewController, global::System.Action completionHandler) => _restoreUserInterfaceForPictureInPicture.OnNext((playerViewController, completionHandler)); + /// + public override void WillBeginFullScreenPresentation(global::AVKit.AVPlayerViewController playerViewController, global::UIKit.IUIViewControllerTransitionCoordinator coordinator) => _willBeginFullScreenPresentation.OnNext((playerViewController, coordinator)); + /// + public override void WillEndFullScreenPresentation(global::AVKit.AVPlayerViewController playerViewController, global::UIKit.IUIViewControllerTransitionCoordinator coordinator) => _willEndFullScreenPresentation.OnNext((playerViewController, coordinator)); + /// + public override void WillStartPictureInPicture(global::AVKit.AVPlayerViewController playerViewController) => _willStartPictureInPicture.OnNext(playerViewController); + /// + public override void WillStopPictureInPicture(global::AVKit.AVPlayerViewController playerViewController) => _willStopPictureInPicture.OnNext(playerViewController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVRoutePickerViewDelegateRx : global::AVKit.AVRoutePickerViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didEndPresentingRoutes = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willBeginPresentingRoutes = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndPresentingRoutesObs => _didEndPresentingRoutes; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillBeginPresentingRoutesObs => _willBeginPresentingRoutes; + /// + public override void DidEndPresentingRoutes(global::AVKit.AVRoutePickerView routePickerView) => _didEndPresentingRoutes.OnNext(routePickerView); + /// + public override void WillBeginPresentingRoutes(global::AVKit.AVRoutePickerView routePickerView) => _willBeginPresentingRoutes.OnNext(routePickerView); + } +} + +namespace CallKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CXCallDirectoryExtensionContextDelegateRx : global::CallKit.CXCallDirectoryExtensionContextDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXCallDirectoryExtensionContext extensionContext, global::Foundation.NSError error)> _requestFailed = new Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXCallDirectoryExtensionContext extensionContext, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CallKit.CXCallDirectoryExtensionContext extensionContext, global::Foundation.NSError error)> RequestFailedObs => _requestFailed; + /// + public override void RequestFailed(global::CallKit.CXCallDirectoryExtensionContext extensionContext, global::Foundation.NSError error) => _requestFailed.OnNext((extensionContext, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CXCallObserverDelegateRx : global::CallKit.CXCallObserverDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXCallObserver callObserver, global::CallKit.CXCall call)> _callChanged = new Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXCallObserver callObserver, global::CallKit.CXCall call)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CallKit.CXCallObserver callObserver, global::CallKit.CXCall call)> CallChangedObs => _callChanged; + /// + public override void CallChanged(global::CallKit.CXCallObserver callObserver, global::CallKit.CXCall call) => _callChanged.OnNext((callObserver, call)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CXProviderDelegateRx : global::CallKit.CXProviderDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::AVFoundation.AVAudioSession audioSession)> _didActivateAudioSession = new Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::AVFoundation.AVAudioSession audioSession)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didBegin = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::AVFoundation.AVAudioSession audioSession)> _didDeactivateAudioSession = new Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::AVFoundation.AVAudioSession audioSession)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didReset = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXAnswerCallAction action)> _performAnswerCallAction = new Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXAnswerCallAction action)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXEndCallAction action)> _performEndCallAction = new Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXEndCallAction action)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXPlayDtmfCallAction action)> _performPlayDtmfCallAction = new Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXPlayDtmfCallAction action)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXSetGroupCallAction action)> _performSetGroupCallAction = new Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXSetGroupCallAction action)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXSetHeldCallAction action)> _performSetHeldCallAction = new Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXSetHeldCallAction action)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXSetMutedCallAction action)> _performSetMutedCallAction = new Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXSetMutedCallAction action)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXStartCallAction action)> _performStartCallAction = new Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXStartCallAction action)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXAction action)> _timedOutPerformingAction = new Pharmacist.Common.SingleAwaitSubject<(global::CallKit.CXProvider provider, global::CallKit.CXAction action)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CallKit.CXProvider provider, global::AVFoundation.AVAudioSession audioSession)> DidActivateAudioSessionObs => _didActivateAudioSession; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBeginObs => _didBegin; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CallKit.CXProvider provider, global::AVFoundation.AVAudioSession audioSession)> DidDeactivateAudioSessionObs => _didDeactivateAudioSession; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidResetObs => _didReset; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CallKit.CXProvider provider, global::CallKit.CXAnswerCallAction action)> PerformAnswerCallActionObs => _performAnswerCallAction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CallKit.CXProvider provider, global::CallKit.CXEndCallAction action)> PerformEndCallActionObs => _performEndCallAction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CallKit.CXProvider provider, global::CallKit.CXPlayDtmfCallAction action)> PerformPlayDtmfCallActionObs => _performPlayDtmfCallAction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CallKit.CXProvider provider, global::CallKit.CXSetGroupCallAction action)> PerformSetGroupCallActionObs => _performSetGroupCallAction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CallKit.CXProvider provider, global::CallKit.CXSetHeldCallAction action)> PerformSetHeldCallActionObs => _performSetHeldCallAction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CallKit.CXProvider provider, global::CallKit.CXSetMutedCallAction action)> PerformSetMutedCallActionObs => _performSetMutedCallAction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CallKit.CXProvider provider, global::CallKit.CXStartCallAction action)> PerformStartCallActionObs => _performStartCallAction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CallKit.CXProvider provider, global::CallKit.CXAction action)> TimedOutPerformingActionObs => _timedOutPerformingAction; + /// + public override void DidActivateAudioSession(global::CallKit.CXProvider provider, global::AVFoundation.AVAudioSession audioSession) => _didActivateAudioSession.OnNext((provider, audioSession)); + /// + public override void DidBegin(global::CallKit.CXProvider provider) => _didBegin.OnNext(provider); + /// + public override void DidDeactivateAudioSession(global::CallKit.CXProvider provider, global::AVFoundation.AVAudioSession audioSession) => _didDeactivateAudioSession.OnNext((provider, audioSession)); + /// + public override void DidReset(global::CallKit.CXProvider provider) => _didReset.OnNext(provider); + /// + public override void PerformAnswerCallAction(global::CallKit.CXProvider provider, global::CallKit.CXAnswerCallAction action) => _performAnswerCallAction.OnNext((provider, action)); + /// + public override void PerformEndCallAction(global::CallKit.CXProvider provider, global::CallKit.CXEndCallAction action) => _performEndCallAction.OnNext((provider, action)); + /// + public override void PerformPlayDtmfCallAction(global::CallKit.CXProvider provider, global::CallKit.CXPlayDtmfCallAction action) => _performPlayDtmfCallAction.OnNext((provider, action)); + /// + public override void PerformSetGroupCallAction(global::CallKit.CXProvider provider, global::CallKit.CXSetGroupCallAction action) => _performSetGroupCallAction.OnNext((provider, action)); + /// + public override void PerformSetHeldCallAction(global::CallKit.CXProvider provider, global::CallKit.CXSetHeldCallAction action) => _performSetHeldCallAction.OnNext((provider, action)); + /// + public override void PerformSetMutedCallAction(global::CallKit.CXProvider provider, global::CallKit.CXSetMutedCallAction action) => _performSetMutedCallAction.OnNext((provider, action)); + /// + public override void PerformStartCallAction(global::CallKit.CXProvider provider, global::CallKit.CXStartCallAction action) => _performStartCallAction.OnNext((provider, action)); + /// + public override void TimedOutPerformingAction(global::CallKit.CXProvider provider, global::CallKit.CXAction action) => _timedOutPerformingAction.OnNext((provider, action)); + } +} + +namespace CarPlay +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CPApplicationDelegateRx : global::CarPlay.CPApplicationDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _applicationSignificantTimeChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CoreGraphics.CGRect oldStatusBarFrame)> _changedStatusBarFrame = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CoreGraphics.CGRect oldStatusBarFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation oldStatusBarOrientation)> _didChangeStatusBarOrientation = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation oldStatusBarOrientation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window)> _didConnectCarInterfaceController = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSCoder coder)> _didDecodeRestorableState = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSCoder coder)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSSet sceneSessions)> _didDiscardSceneSessions = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSSet sceneSessions)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window)> _didDisconnectCarInterfaceController = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEnterBackground = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, string userActivityType, global::Foundation.NSError error)> _didFailToContinueUserActivitiy = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, string userActivityType, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action completionHandler)> _didReceiveRemoteNotification = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIUserNotificationSettings notificationSettings)> _didRegisterUserNotificationSettings = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIUserNotificationSettings notificationSettings)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CarPlay.CPManeuver maneuver)> _didSelectManeuver = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CarPlay.CPManeuver maneuver)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CarPlay.CPNavigationAlert navigationAlert)> _didSelectNavigationAlert = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CarPlay.CPNavigationAlert navigationAlert)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSError error)> _failedToRegisterForRemoteNotifications = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _finishedLaunching = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, string actionIdentifier, global::UIKit.UILocalNotification localNotification, global::Foundation.NSDictionary responseInfo, global::System.Action completionHandler)> _handleAction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, string actionIdentifier, global::UIKit.UILocalNotification localNotification, global::Foundation.NSDictionary responseInfo, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, string sessionIdentifier, global::System.Action completionHandler)> _handleEventsForBackgroundUrl = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, string sessionIdentifier, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Intents.INIntent intent, global::System.Action completionHandler)> _handleIntent = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Intents.INIntent intent, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action reply)> _handleWatchKitExtensionRequest = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action reply)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _onActivated = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _onResignActivation = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIApplicationShortcutItem shortcutItem, global::UIKit.UIOperationHandler completionHandler)> _performActionForShortcutItem = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIApplicationShortcutItem shortcutItem, global::UIKit.UIOperationHandler completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::System.Action completionHandler)> _performFetch = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _protectedDataDidBecomeAvailable = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _protectedDataWillBecomeUnavailable = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UILocalNotification notification)> _receivedLocalNotification = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UILocalNotification notification)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo)> _receivedRemoteNotification = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _receiveMemoryWarning = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSData deviceToken)> _registeredForRemoteNotifications = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSData deviceToken)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _shouldRequestHealthAuthorization = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSUserActivity userActivity)> _userActivityUpdated = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSUserActivity userActivity)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CloudKit.CKShareMetadata cloudKitShareMetadata)> _userDidAcceptCloudKitShare = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CloudKit.CKShareMetadata cloudKitShareMetadata)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CoreGraphics.CGRect newStatusBarFrame)> _willChangeStatusBarFrame = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CoreGraphics.CGRect newStatusBarFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation newStatusBarOrientation, double duration)> _willChangeStatusBarOrientation = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation newStatusBarOrientation, double duration)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSCoder coder)> _willEncodeRestorableState = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSCoder coder)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willEnterForeground = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willTerminate = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ApplicationSignificantTimeChangeObs => _applicationSignificantTimeChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::CoreGraphics.CGRect oldStatusBarFrame)> ChangedStatusBarFrameObs => _changedStatusBarFrame; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation oldStatusBarOrientation)> DidChangeStatusBarOrientationObs => _didChangeStatusBarOrientation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window)> DidConnectCarInterfaceControllerObs => _didConnectCarInterfaceController; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSCoder coder)> DidDecodeRestorableStateObs => _didDecodeRestorableState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSSet sceneSessions)> DidDiscardSceneSessionsObs => _didDiscardSceneSessions; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window)> DidDisconnectCarInterfaceControllerObs => _didDisconnectCarInterfaceController; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEnterBackgroundObs => _didEnterBackground; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, string userActivityType, global::Foundation.NSError error)> DidFailToContinueUserActivitiyObs => _didFailToContinueUserActivitiy; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action completionHandler)> DidReceiveRemoteNotificationObs => _didReceiveRemoteNotification; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::UIKit.UIUserNotificationSettings notificationSettings)> DidRegisterUserNotificationSettingsObs => _didRegisterUserNotificationSettings; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::CarPlay.CPManeuver maneuver)> DidSelectManeuverObs => _didSelectManeuver; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::CarPlay.CPNavigationAlert navigationAlert)> DidSelectNavigationAlertObs => _didSelectNavigationAlert; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSError error)> FailedToRegisterForRemoteNotificationsObs => _failedToRegisterForRemoteNotifications; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedLaunchingObs => _finishedLaunching; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, string actionIdentifier, global::UIKit.UILocalNotification localNotification, global::Foundation.NSDictionary responseInfo, global::System.Action completionHandler)> HandleActionObs => _handleAction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, string sessionIdentifier, global::System.Action completionHandler)> HandleEventsForBackgroundUrlObs => _handleEventsForBackgroundUrl; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Intents.INIntent intent, global::System.Action completionHandler)> HandleIntentObs => _handleIntent; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action reply)> HandleWatchKitExtensionRequestObs => _handleWatchKitExtensionRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OnActivatedObs => _onActivated; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OnResignActivationObs => _onResignActivation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::UIKit.UIApplicationShortcutItem shortcutItem, global::UIKit.UIOperationHandler completionHandler)> PerformActionForShortcutItemObs => _performActionForShortcutItem; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::System.Action completionHandler)> PerformFetchObs => _performFetch; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ProtectedDataDidBecomeAvailableObs => _protectedDataDidBecomeAvailable; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ProtectedDataWillBecomeUnavailableObs => _protectedDataWillBecomeUnavailable; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::UIKit.UILocalNotification notification)> ReceivedLocalNotificationObs => _receivedLocalNotification; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo)> ReceivedRemoteNotificationObs => _receivedRemoteNotification; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ReceiveMemoryWarningObs => _receiveMemoryWarning; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSData deviceToken)> RegisteredForRemoteNotificationsObs => _registeredForRemoteNotifications; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ShouldRequestHealthAuthorizationObs => _shouldRequestHealthAuthorization; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSUserActivity userActivity)> UserActivityUpdatedObs => _userActivityUpdated; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::CloudKit.CKShareMetadata cloudKitShareMetadata)> UserDidAcceptCloudKitShareObs => _userDidAcceptCloudKitShare; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::CoreGraphics.CGRect newStatusBarFrame)> WillChangeStatusBarFrameObs => _willChangeStatusBarFrame; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation newStatusBarOrientation, double duration)> WillChangeStatusBarOrientationObs => _willChangeStatusBarOrientation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSCoder coder)> WillEncodeRestorableStateObs => _willEncodeRestorableState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillEnterForegroundObs => _willEnterForeground; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillTerminateObs => _willTerminate; + /// + public override void ApplicationSignificantTimeChange(global::UIKit.UIApplication application) => _applicationSignificantTimeChange.OnNext(application); + /// + public override void ChangedStatusBarFrame(global::UIKit.UIApplication application, global::CoreGraphics.CGRect oldStatusBarFrame) => _changedStatusBarFrame.OnNext((application, oldStatusBarFrame)); + /// + public override void DidChangeStatusBarOrientation(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation oldStatusBarOrientation) => _didChangeStatusBarOrientation.OnNext((application, oldStatusBarOrientation)); + /// + public override void DidConnectCarInterfaceController(global::UIKit.UIApplication application, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window) => _didConnectCarInterfaceController.OnNext((application, interfaceController, window)); + /// + public override void DidDecodeRestorableState(global::UIKit.UIApplication application, global::Foundation.NSCoder coder) => _didDecodeRestorableState.OnNext((application, coder)); + /// + public override void DidDiscardSceneSessions(global::UIKit.UIApplication application, global::Foundation.NSSet sceneSessions) => _didDiscardSceneSessions.OnNext((application, sceneSessions)); + /// + public override void DidDisconnectCarInterfaceController(global::UIKit.UIApplication application, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window) => _didDisconnectCarInterfaceController.OnNext((application, interfaceController, window)); + /// + public override void DidEnterBackground(global::UIKit.UIApplication application) => _didEnterBackground.OnNext(application); + /// + public override void DidFailToContinueUserActivitiy(global::UIKit.UIApplication application, string userActivityType, global::Foundation.NSError error) => _didFailToContinueUserActivitiy.OnNext((application, userActivityType, error)); + /// + public override void DidReceiveRemoteNotification(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action completionHandler) => _didReceiveRemoteNotification.OnNext((application, userInfo, completionHandler)); + /// + public override void DidRegisterUserNotificationSettings(global::UIKit.UIApplication application, global::UIKit.UIUserNotificationSettings notificationSettings) => _didRegisterUserNotificationSettings.OnNext((application, notificationSettings)); + /// + public override void DidSelectManeuver(global::UIKit.UIApplication application, global::CarPlay.CPManeuver maneuver) => _didSelectManeuver.OnNext((application, maneuver)); + /// + public override void DidSelectNavigationAlert(global::UIKit.UIApplication application, global::CarPlay.CPNavigationAlert navigationAlert) => _didSelectNavigationAlert.OnNext((application, navigationAlert)); + /// + public override void FailedToRegisterForRemoteNotifications(global::UIKit.UIApplication application, global::Foundation.NSError error) => _failedToRegisterForRemoteNotifications.OnNext((application, error)); + /// + public override void FinishedLaunching(global::UIKit.UIApplication application) => _finishedLaunching.OnNext(application); + /// + public override void HandleAction(global::UIKit.UIApplication application, string actionIdentifier, global::UIKit.UILocalNotification localNotification, global::Foundation.NSDictionary responseInfo, global::System.Action completionHandler) => _handleAction.OnNext((application, actionIdentifier, localNotification, responseInfo, completionHandler)); + /// + public override void HandleEventsForBackgroundUrl(global::UIKit.UIApplication application, string sessionIdentifier, global::System.Action completionHandler) => _handleEventsForBackgroundUrl.OnNext((application, sessionIdentifier, completionHandler)); + /// + public override void HandleIntent(global::UIKit.UIApplication application, global::Intents.INIntent intent, global::System.Action completionHandler) => _handleIntent.OnNext((application, intent, completionHandler)); + /// + public override void HandleWatchKitExtensionRequest(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action reply) => _handleWatchKitExtensionRequest.OnNext((application, userInfo, reply)); + /// + public override void OnActivated(global::UIKit.UIApplication application) => _onActivated.OnNext(application); + /// + public override void OnResignActivation(global::UIKit.UIApplication application) => _onResignActivation.OnNext(application); + /// + public override void PerformActionForShortcutItem(global::UIKit.UIApplication application, global::UIKit.UIApplicationShortcutItem shortcutItem, global::UIKit.UIOperationHandler completionHandler) => _performActionForShortcutItem.OnNext((application, shortcutItem, completionHandler)); + /// + public override void PerformFetch(global::UIKit.UIApplication application, global::System.Action completionHandler) => _performFetch.OnNext((application, completionHandler)); + /// + public override void ProtectedDataDidBecomeAvailable(global::UIKit.UIApplication application) => _protectedDataDidBecomeAvailable.OnNext(application); + /// + public override void ProtectedDataWillBecomeUnavailable(global::UIKit.UIApplication application) => _protectedDataWillBecomeUnavailable.OnNext(application); + /// + public override void ReceivedLocalNotification(global::UIKit.UIApplication application, global::UIKit.UILocalNotification notification) => _receivedLocalNotification.OnNext((application, notification)); + /// + public override void ReceivedRemoteNotification(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo) => _receivedRemoteNotification.OnNext((application, userInfo)); + /// + public override void ReceiveMemoryWarning(global::UIKit.UIApplication application) => _receiveMemoryWarning.OnNext(application); + /// + public override void RegisteredForRemoteNotifications(global::UIKit.UIApplication application, global::Foundation.NSData deviceToken) => _registeredForRemoteNotifications.OnNext((application, deviceToken)); + /// + public override void ShouldRequestHealthAuthorization(global::UIKit.UIApplication application) => _shouldRequestHealthAuthorization.OnNext(application); + /// + public override void UserActivityUpdated(global::UIKit.UIApplication application, global::Foundation.NSUserActivity userActivity) => _userActivityUpdated.OnNext((application, userActivity)); + /// + public override void UserDidAcceptCloudKitShare(global::UIKit.UIApplication application, global::CloudKit.CKShareMetadata cloudKitShareMetadata) => _userDidAcceptCloudKitShare.OnNext((application, cloudKitShareMetadata)); + /// + public override void WillChangeStatusBarFrame(global::UIKit.UIApplication application, global::CoreGraphics.CGRect newStatusBarFrame) => _willChangeStatusBarFrame.OnNext((application, newStatusBarFrame)); + /// + public override void WillChangeStatusBarOrientation(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation newStatusBarOrientation, double duration) => _willChangeStatusBarOrientation.OnNext((application, newStatusBarOrientation, duration)); + /// + public override void WillEncodeRestorableState(global::UIKit.UIApplication application, global::Foundation.NSCoder coder) => _willEncodeRestorableState.OnNext((application, coder)); + /// + public override void WillEnterForeground(global::UIKit.UIApplication application) => _willEnterForeground.OnNext(application); + /// + public override void WillTerminate(global::UIKit.UIApplication application) => _willTerminate.OnNext(application); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class CPInterfaceControllerDelegateRx : global::CarPlay.CPInterfaceControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplate aTemplate, bool animated)> _templateDidAppear = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplate aTemplate, bool animated)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplate aTemplate, bool animated)> _templateDidDisappear = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplate aTemplate, bool animated)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplate aTemplate, bool animated)> _templateWillAppear = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplate aTemplate, bool animated)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplate aTemplate, bool animated)> _templateWillDisappear = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplate aTemplate, bool animated)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPTemplate aTemplate, bool animated)> TemplateDidAppearObs => _templateDidAppear; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPTemplate aTemplate, bool animated)> TemplateDidDisappearObs => _templateDidDisappear; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPTemplate aTemplate, bool animated)> TemplateWillAppearObs => _templateWillAppear; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPTemplate aTemplate, bool animated)> TemplateWillDisappearObs => _templateWillDisappear; + /// + public override void TemplateDidAppear(global::CarPlay.CPTemplate aTemplate, bool animated) => _templateDidAppear.OnNext((aTemplate, animated)); + /// + public override void TemplateDidDisappear(global::CarPlay.CPTemplate aTemplate, bool animated) => _templateDidDisappear.OnNext((aTemplate, animated)); + /// + public override void TemplateWillAppear(global::CarPlay.CPTemplate aTemplate, bool animated) => _templateWillAppear.OnNext((aTemplate, animated)); + /// + public override void TemplateWillDisappear(global::CarPlay.CPTemplate aTemplate, bool animated) => _templateWillDisappear.OnNext((aTemplate, animated)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CPListTemplateDelegateRx : global::CarPlay.CPListTemplateDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPListTemplate listTemplate, global::CarPlay.CPListItem item, global::System.Action completionHandler)> _didSelectListItem = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPListTemplate listTemplate, global::CarPlay.CPListItem item, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPListTemplate listTemplate, global::CarPlay.CPListItem item, global::System.Action completionHandler)> DidSelectListItemObs => _didSelectListItem; + /// + public override void DidSelectListItem(global::CarPlay.CPListTemplate listTemplate, global::CarPlay.CPListItem item, global::System.Action completionHandler) => _didSelectListItem.OnNext((listTemplate, item, completionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class CPMapTemplateDelegateRx : global::CarPlay.CPMapTemplateDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBeginPanGesture = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didCancelNavigation = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert, global::CarPlay.CPNavigationAlertDismissalContext dismissalContext)> _didDismissNavigationAlert = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert, global::CarPlay.CPNavigationAlertDismissalContext dismissalContext)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didDismissPanningInterface = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CoreGraphics.CGPoint velocity)> _didEndPanGesture = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CoreGraphics.CGPoint velocity)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert)> _didShowNavigationAlert = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didShowPanningInterface = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CoreGraphics.CGPoint translation, global::CoreGraphics.CGPoint velocity)> _didUpdatePanGesture = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CoreGraphics.CGPoint translation, global::CoreGraphics.CGPoint velocity)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPPanDirection direction)> _pan = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPPanDirection direction)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPPanDirection direction)> _panBegan = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPPanDirection direction)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPPanDirection direction)> _panEnded = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPPanDirection direction)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPTrip trip, global::CarPlay.CPRouteChoice routeChoice)> _selectedPreview = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPTrip trip, global::CarPlay.CPRouteChoice routeChoice)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPTrip trip, global::CarPlay.CPRouteChoice routeChoice)> _startedTrip = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPTrip trip, global::CarPlay.CPRouteChoice routeChoice)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert, global::CarPlay.CPNavigationAlertDismissalContext dismissalContext)> _willDismissNavigationAlert = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert, global::CarPlay.CPNavigationAlertDismissalContext dismissalContext)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willDismissPanningInterface = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert)> _willShowNavigationAlert = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBeginPanGestureObs => _didBeginPanGesture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidCancelNavigationObs => _didCancelNavigation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert, global::CarPlay.CPNavigationAlertDismissalContext dismissalContext)> DidDismissNavigationAlertObs => _didDismissNavigationAlert; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDismissPanningInterfaceObs => _didDismissPanningInterface; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPMapTemplate mapTemplate, global::CoreGraphics.CGPoint velocity)> DidEndPanGestureObs => _didEndPanGesture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert)> DidShowNavigationAlertObs => _didShowNavigationAlert; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidShowPanningInterfaceObs => _didShowPanningInterface; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPMapTemplate mapTemplate, global::CoreGraphics.CGPoint translation, global::CoreGraphics.CGPoint velocity)> DidUpdatePanGestureObs => _didUpdatePanGesture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPPanDirection direction)> PanObs => _pan; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPPanDirection direction)> PanBeganObs => _panBegan; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPPanDirection direction)> PanEndedObs => _panEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPTrip trip, global::CarPlay.CPRouteChoice routeChoice)> SelectedPreviewObs => _selectedPreview; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPTrip trip, global::CarPlay.CPRouteChoice routeChoice)> StartedTripObs => _startedTrip; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert, global::CarPlay.CPNavigationAlertDismissalContext dismissalContext)> WillDismissNavigationAlertObs => _willDismissNavigationAlert; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillDismissPanningInterfaceObs => _willDismissPanningInterface; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert)> WillShowNavigationAlertObs => _willShowNavigationAlert; + /// + public override void DidBeginPanGesture(global::CarPlay.CPMapTemplate mapTemplate) => _didBeginPanGesture.OnNext(mapTemplate); + /// + public override void DidCancelNavigation(global::CarPlay.CPMapTemplate mapTemplate) => _didCancelNavigation.OnNext(mapTemplate); + /// + public override void DidDismissNavigationAlert(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert, global::CarPlay.CPNavigationAlertDismissalContext dismissalContext) => _didDismissNavigationAlert.OnNext((mapTemplate, navigationAlert, dismissalContext)); + /// + public override void DidDismissPanningInterface(global::CarPlay.CPMapTemplate mapTemplate) => _didDismissPanningInterface.OnNext(mapTemplate); + /// + public override void DidEndPanGesture(global::CarPlay.CPMapTemplate mapTemplate, global::CoreGraphics.CGPoint velocity) => _didEndPanGesture.OnNext((mapTemplate, velocity)); + /// + public override void DidShowNavigationAlert(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert) => _didShowNavigationAlert.OnNext((mapTemplate, navigationAlert)); + /// + public override void DidShowPanningInterface(global::CarPlay.CPMapTemplate mapTemplate) => _didShowPanningInterface.OnNext(mapTemplate); + /// + public override void DidUpdatePanGesture(global::CarPlay.CPMapTemplate mapTemplate, global::CoreGraphics.CGPoint translation, global::CoreGraphics.CGPoint velocity) => _didUpdatePanGesture.OnNext((mapTemplate, translation, velocity)); + /// + public override void Pan(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPPanDirection direction) => _pan.OnNext((mapTemplate, direction)); + /// + public override void PanBegan(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPPanDirection direction) => _panBegan.OnNext((mapTemplate, direction)); + /// + public override void PanEnded(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPPanDirection direction) => _panEnded.OnNext((mapTemplate, direction)); + /// + public override void SelectedPreview(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPTrip trip, global::CarPlay.CPRouteChoice routeChoice) => _selectedPreview.OnNext((mapTemplate, trip, routeChoice)); + /// + public override void StartedTrip(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPTrip trip, global::CarPlay.CPRouteChoice routeChoice) => _startedTrip.OnNext((mapTemplate, trip, routeChoice)); + /// + public override void WillDismissNavigationAlert(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert, global::CarPlay.CPNavigationAlertDismissalContext dismissalContext) => _willDismissNavigationAlert.OnNext((mapTemplate, navigationAlert, dismissalContext)); + /// + public override void WillDismissPanningInterface(global::CarPlay.CPMapTemplate mapTemplate) => _willDismissPanningInterface.OnNext(mapTemplate); + /// + public override void WillShowNavigationAlert(global::CarPlay.CPMapTemplate mapTemplate, global::CarPlay.CPNavigationAlert navigationAlert) => _willShowNavigationAlert.OnNext((mapTemplate, navigationAlert)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CPPointOfInterestTemplateDelegateRx : global::CarPlay.CPPointOfInterestTemplateDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPPointOfInterestTemplate pointOfInterestTemplate, global::MapKit.MKCoordinateRegion region)> _didChangeMapRegion = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPPointOfInterestTemplate pointOfInterestTemplate, global::MapKit.MKCoordinateRegion region)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPPointOfInterestTemplate pointOfInterestTemplate, global::CarPlay.CPPointOfInterest pointOfInterest)> _didSelectPointOfInterest = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPPointOfInterestTemplate pointOfInterestTemplate, global::CarPlay.CPPointOfInterest pointOfInterest)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPPointOfInterestTemplate pointOfInterestTemplate, global::MapKit.MKCoordinateRegion region)> DidChangeMapRegionObs => _didChangeMapRegion; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPPointOfInterestTemplate pointOfInterestTemplate, global::CarPlay.CPPointOfInterest pointOfInterest)> DidSelectPointOfInterestObs => _didSelectPointOfInterest; + /// + public override void DidChangeMapRegion(global::CarPlay.CPPointOfInterestTemplate pointOfInterestTemplate, global::MapKit.MKCoordinateRegion region) => _didChangeMapRegion.OnNext((pointOfInterestTemplate, region)); + /// + public override void DidSelectPointOfInterest(global::CarPlay.CPPointOfInterestTemplate pointOfInterestTemplate, global::CarPlay.CPPointOfInterest pointOfInterest) => _didSelectPointOfInterest.OnNext((pointOfInterestTemplate, pointOfInterest)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CPSearchTemplateDelegateRx : global::CarPlay.CPSearchTemplateDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _searchButtonPressed = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPSearchTemplate searchTemplate, global::CarPlay.CPListItem item, global::System.Action completionHandler)> _selectedResult = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPSearchTemplate searchTemplate, global::CarPlay.CPListItem item, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPSearchTemplate searchTemplate, string searchText, global::CarPlay.CPSearchTemplateDelegateUpdateHandler completionHandler)> _updatedSearchText = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPSearchTemplate searchTemplate, string searchText, global::CarPlay.CPSearchTemplateDelegateUpdateHandler completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SearchButtonPressedObs => _searchButtonPressed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPSearchTemplate searchTemplate, global::CarPlay.CPListItem item, global::System.Action completionHandler)> SelectedResultObs => _selectedResult; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPSearchTemplate searchTemplate, string searchText, global::CarPlay.CPSearchTemplateDelegateUpdateHandler completionHandler)> UpdatedSearchTextObs => _updatedSearchText; + /// + public override void SearchButtonPressed(global::CarPlay.CPSearchTemplate searchTemplate) => _searchButtonPressed.OnNext(searchTemplate); + /// + public override void SelectedResult(global::CarPlay.CPSearchTemplate searchTemplate, global::CarPlay.CPListItem item, global::System.Action completionHandler) => _selectedResult.OnNext((searchTemplate, item, completionHandler)); + /// + public override void UpdatedSearchText(global::CarPlay.CPSearchTemplate searchTemplate, string searchText, global::CarPlay.CPSearchTemplateDelegateUpdateHandler completionHandler) => _updatedSearchText.OnNext((searchTemplate, searchText, completionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CPSessionConfigurationDelegateRx : global::CarPlay.CPSessionConfigurationDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPSessionConfiguration sessionConfiguration, global::CarPlay.CPContentStyle contentStyle)> _contentStyleChanged = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPSessionConfiguration sessionConfiguration, global::CarPlay.CPContentStyle contentStyle)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPSessionConfiguration sessionConfiguration, global::CarPlay.CPLimitableUserInterface limitedUserInterfaces)> _limitedUserInterfacesChanged = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPSessionConfiguration sessionConfiguration, global::CarPlay.CPLimitableUserInterface limitedUserInterfaces)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPSessionConfiguration sessionConfiguration, global::CarPlay.CPContentStyle contentStyle)> ContentStyleChangedObs => _contentStyleChanged; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPSessionConfiguration sessionConfiguration, global::CarPlay.CPLimitableUserInterface limitedUserInterfaces)> LimitedUserInterfacesChangedObs => _limitedUserInterfacesChanged; + /// + public override void ContentStyleChanged(global::CarPlay.CPSessionConfiguration sessionConfiguration, global::CarPlay.CPContentStyle contentStyle) => _contentStyleChanged.OnNext((sessionConfiguration, contentStyle)); + /// + public override void LimitedUserInterfacesChanged(global::CarPlay.CPSessionConfiguration sessionConfiguration, global::CarPlay.CPLimitableUserInterface limitedUserInterfaces) => _limitedUserInterfacesChanged.OnNext((sessionConfiguration, limitedUserInterfaces)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CPTabBarTemplateDelegateRx : global::CarPlay.CPTabBarTemplateDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTabBarTemplate tabBarTemplate, global::CarPlay.CPTemplate selectedTemplate)> _didSelectTemplate = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTabBarTemplate tabBarTemplate, global::CarPlay.CPTemplate selectedTemplate)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPTabBarTemplate tabBarTemplate, global::CarPlay.CPTemplate selectedTemplate)> DidSelectTemplateObs => _didSelectTemplate; + /// + public override void DidSelectTemplate(global::CarPlay.CPTabBarTemplate tabBarTemplate, global::CarPlay.CPTemplate selectedTemplate) => _didSelectTemplate.OnNext((tabBarTemplate, selectedTemplate)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class CPTemplateApplicationDashboardSceneDelegateRx : global::CarPlay.CPTemplateApplicationDashboardSceneDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> _continueUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeActive = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplateApplicationDashboardScene templateApplicationDashboardScene, global::CarPlay.CPDashboardController dashboardController, global::UIKit.UIWindow window)> _didConnectDashboardController = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplateApplicationDashboardScene templateApplicationDashboardScene, global::CarPlay.CPDashboardController dashboardController, global::UIKit.UIWindow window)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didDisconnect = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplateApplicationDashboardScene templateApplicationDashboardScene, global::CarPlay.CPDashboardController dashboardController, global::UIKit.UIWindow window)> _didDisconnectDashboardController = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplateApplicationDashboardScene templateApplicationDashboardScene, global::CarPlay.CPDashboardController dashboardController, global::UIKit.UIWindow window)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEnterBackground = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error)> _didFailToContinueUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> _didUpdateUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts)> _openUrlContexts = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions)> _willConnect = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType)> _willContinueUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willEnterForeground = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willResignActive = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> ContinueUserActivityObs => _continueUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeActiveObs => _didBecomeActive; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPTemplateApplicationDashboardScene templateApplicationDashboardScene, global::CarPlay.CPDashboardController dashboardController, global::UIKit.UIWindow window)> DidConnectDashboardControllerObs => _didConnectDashboardController; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDisconnectObs => _didDisconnect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPTemplateApplicationDashboardScene templateApplicationDashboardScene, global::CarPlay.CPDashboardController dashboardController, global::UIKit.UIWindow window)> DidDisconnectDashboardControllerObs => _didDisconnectDashboardController; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEnterBackgroundObs => _didEnterBackground; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error)> DidFailToContinueUserActivityObs => _didFailToContinueUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> DidUpdateUserActivityObs => _didUpdateUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts)> OpenUrlContextsObs => _openUrlContexts; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions)> WillConnectObs => _willConnect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, string userActivityType)> WillContinueUserActivityObs => _willContinueUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillEnterForegroundObs => _willEnterForeground; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillResignActiveObs => _willResignActive; + /// + public override void ContinueUserActivity(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity) => _continueUserActivity.OnNext((scene, userActivity)); + /// + public override void DidBecomeActive(global::UIKit.UIScene scene) => _didBecomeActive.OnNext(scene); + /// + public override void DidConnectDashboardController(global::CarPlay.CPTemplateApplicationDashboardScene templateApplicationDashboardScene, global::CarPlay.CPDashboardController dashboardController, global::UIKit.UIWindow window) => _didConnectDashboardController.OnNext((templateApplicationDashboardScene, dashboardController, window)); + /// + public override void DidDisconnect(global::UIKit.UIScene scene) => _didDisconnect.OnNext(scene); + /// + public override void DidDisconnectDashboardController(global::CarPlay.CPTemplateApplicationDashboardScene templateApplicationDashboardScene, global::CarPlay.CPDashboardController dashboardController, global::UIKit.UIWindow window) => _didDisconnectDashboardController.OnNext((templateApplicationDashboardScene, dashboardController, window)); + /// + public override void DidEnterBackground(global::UIKit.UIScene scene) => _didEnterBackground.OnNext(scene); + /// + public override void DidFailToContinueUserActivity(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error) => _didFailToContinueUserActivity.OnNext((scene, userActivityType, error)); + /// + public override void DidUpdateUserActivity(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity) => _didUpdateUserActivity.OnNext((scene, userActivity)); + /// + public override void OpenUrlContexts(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts) => _openUrlContexts.OnNext((scene, urlContexts)); + /// + public override void WillConnect(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions) => _willConnect.OnNext((scene, session, connectionOptions)); + /// + public override void WillContinueUserActivity(global::UIKit.UIScene scene, string userActivityType) => _willContinueUserActivity.OnNext((scene, userActivityType)); + /// + public override void WillEnterForeground(global::UIKit.UIScene scene) => _willEnterForeground.OnNext(scene); + /// + public override void WillResignActive(global::UIKit.UIScene scene) => _willResignActive.OnNext(scene); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class CPTemplateApplicationSceneDelegateRx : global::CarPlay.CPTemplateApplicationSceneDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> _continueUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeActive = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplateApplicationScene templateApplicationScene, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window)> _didConnect = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplateApplicationScene templateApplicationScene, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplateApplicationScene templateApplicationScene, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window)> _didDisconnect = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplateApplicationScene templateApplicationScene, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEnterBackground = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error)> _didFailToContinueUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplateApplicationScene templateApplicationScene, global::CarPlay.CPNavigationAlert navigationAlert)> _didSelect = new Pharmacist.Common.SingleAwaitSubject<(global::CarPlay.CPTemplateApplicationScene templateApplicationScene, global::CarPlay.CPNavigationAlert navigationAlert)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> _didUpdateUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts)> _openUrlContexts = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions)> _willConnect = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType)> _willContinueUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willEnterForeground = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willResignActive = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> ContinueUserActivityObs => _continueUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeActiveObs => _didBecomeActive; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPTemplateApplicationScene templateApplicationScene, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window)> DidConnectObs => _didConnect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPTemplateApplicationScene templateApplicationScene, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window)> DidDisconnectObs => _didDisconnect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEnterBackgroundObs => _didEnterBackground; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error)> DidFailToContinueUserActivityObs => _didFailToContinueUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CarPlay.CPTemplateApplicationScene templateApplicationScene, global::CarPlay.CPNavigationAlert navigationAlert)> DidSelectObs => _didSelect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> DidUpdateUserActivityObs => _didUpdateUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts)> OpenUrlContextsObs => _openUrlContexts; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions)> WillConnectObs => _willConnect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, string userActivityType)> WillContinueUserActivityObs => _willContinueUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillEnterForegroundObs => _willEnterForeground; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillResignActiveObs => _willResignActive; + /// + public override void ContinueUserActivity(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity) => _continueUserActivity.OnNext((scene, userActivity)); + /// + public override void DidBecomeActive(global::UIKit.UIScene scene) => _didBecomeActive.OnNext(scene); + /// + public override void DidConnect(global::CarPlay.CPTemplateApplicationScene templateApplicationScene, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window) => _didConnect.OnNext((templateApplicationScene, interfaceController, window)); + /// + public override void DidDisconnect(global::CarPlay.CPTemplateApplicationScene templateApplicationScene, global::CarPlay.CPInterfaceController interfaceController, global::CarPlay.CPWindow window) => _didDisconnect.OnNext((templateApplicationScene, interfaceController, window)); + /// + public override void DidEnterBackground(global::UIKit.UIScene scene) => _didEnterBackground.OnNext(scene); + /// + public override void DidFailToContinueUserActivity(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error) => _didFailToContinueUserActivity.OnNext((scene, userActivityType, error)); + /// + public override void DidSelect(global::CarPlay.CPTemplateApplicationScene templateApplicationScene, global::CarPlay.CPNavigationAlert navigationAlert) => _didSelect.OnNext((templateApplicationScene, navigationAlert)); + /// + public override void DidUpdateUserActivity(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity) => _didUpdateUserActivity.OnNext((scene, userActivity)); + /// + public override void OpenUrlContexts(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts) => _openUrlContexts.OnNext((scene, urlContexts)); + /// + public override void WillConnect(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions) => _willConnect.OnNext((scene, session, connectionOptions)); + /// + public override void WillContinueUserActivity(global::UIKit.UIScene scene, string userActivityType) => _willContinueUserActivity.OnNext((scene, userActivityType)); + /// + public override void WillEnterForeground(global::UIKit.UIScene scene) => _willEnterForeground.OnNext(scene); + /// + public override void WillResignActive(global::UIKit.UIScene scene) => _willResignActive.OnNext(scene); + } +} + +namespace ContactsUI +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class CNContactPickerDelegateRx : global::ContactsUI.CNContactPickerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _contactPickerDidCancel = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContact contact)> _didSelectContact = new Pharmacist.Common.SingleAwaitSubject<(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContact contact)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContactProperty[] contactProperties)> _didSelectContactProperties = new Pharmacist.Common.SingleAwaitSubject<(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContactProperty[] contactProperties)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContactProperty contactProperty)> _didSelectContactProperty = new Pharmacist.Common.SingleAwaitSubject<(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContactProperty contactProperty)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContact[] contacts)> _didSelectContacts = new Pharmacist.Common.SingleAwaitSubject<(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContact[] contacts)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ContactPickerDidCancelObs => _contactPickerDidCancel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContact contact)> DidSelectContactObs => _didSelectContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContactProperty[] contactProperties)> DidSelectContactPropertiesObs => _didSelectContactProperties; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContactProperty contactProperty)> DidSelectContactPropertyObs => _didSelectContactProperty; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContact[] contacts)> DidSelectContactsObs => _didSelectContacts; + /// + public override void ContactPickerDidCancel(global::ContactsUI.CNContactPickerViewController picker) => _contactPickerDidCancel.OnNext(picker); + /// + public override void DidSelectContact(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContact contact) => _didSelectContact.OnNext((picker, contact)); + /// + public override void DidSelectContactProperties(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContactProperty[] contactProperties) => _didSelectContactProperties.OnNext((picker, contactProperties)); + /// + public override void DidSelectContactProperty(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContactProperty contactProperty) => _didSelectContactProperty.OnNext((picker, contactProperty)); + /// + public override void DidSelectContacts(global::ContactsUI.CNContactPickerViewController picker, global::Contacts.CNContact[] contacts) => _didSelectContacts.OnNext((picker, contacts)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class CNContactViewControllerDelegateRx : global::ContactsUI.CNContactViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ContactsUI.CNContactViewController viewController, global::Contacts.CNContact contact)> _didComplete = new Pharmacist.Common.SingleAwaitSubject<(global::ContactsUI.CNContactViewController viewController, global::Contacts.CNContact contact)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ContactsUI.CNContactViewController viewController, global::Contacts.CNContact contact)> DidCompleteObs => _didComplete; + /// + public override void DidComplete(global::ContactsUI.CNContactViewController viewController, global::Contacts.CNContact contact) => _didComplete.OnNext((viewController, contact)); + } +} + +namespace CoreAnimation +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class CAAnimationDelegateRx : global::CoreAnimation.CAAnimationDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _animationStarted = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreAnimation.CAAnimation anim, bool finished)> _animationStopped = new Pharmacist.Common.SingleAwaitSubject<(global::CoreAnimation.CAAnimation anim, bool finished)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable AnimationStartedObs => _animationStarted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreAnimation.CAAnimation anim, bool finished)> AnimationStoppedObs => _animationStopped; + /// + public override void AnimationStarted(global::CoreAnimation.CAAnimation anim) => _animationStarted.OnNext(anim); + /// + public override void AnimationStopped(global::CoreAnimation.CAAnimation anim, bool finished) => _animationStopped.OnNext((anim, finished)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class CALayerDelegateRx : global::CoreAnimation.CALayerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _displayLayer = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreAnimation.CALayer layer, global::CoreGraphics.CGContext context)> _drawLayer = new Pharmacist.Common.SingleAwaitSubject<(global::CoreAnimation.CALayer layer, global::CoreGraphics.CGContext context)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _layoutSublayersOfLayer = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willDrawLayer = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DisplayLayerObs => _displayLayer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreAnimation.CALayer layer, global::CoreGraphics.CGContext context)> DrawLayerObs => _drawLayer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LayoutSublayersOfLayerObs => _layoutSublayersOfLayer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillDrawLayerObs => _willDrawLayer; + /// + public override void DisplayLayer(global::CoreAnimation.CALayer layer) => _displayLayer.OnNext(layer); + /// + public override void DrawLayer(global::CoreAnimation.CALayer layer, global::CoreGraphics.CGContext context) => _drawLayer.OnNext((layer, context)); + /// + public override void LayoutSublayersOfLayer(global::CoreAnimation.CALayer layer) => _layoutSublayersOfLayer.OnNext(layer); + /// + public override void WillDrawLayer(global::CoreAnimation.CALayer layer) => _willDrawLayer.OnNext(layer); + } +} + +namespace CoreBluetooth +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CBCentralManagerDelegateRx : global::CoreBluetooth.CBCentralManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral)> _connectedPeripheral = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBConnectionEvent connectionEvent, global::CoreBluetooth.CBPeripheral peripheral)> _connectionEventDidOccur = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBConnectionEvent connectionEvent, global::CoreBluetooth.CBPeripheral peripheral)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral)> _didUpdateAncsAuthorization = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> _disconnectedPeripheral = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSDictionary advertisementData, global::Foundation.NSNumber RSSI)> _discoveredPeripheral = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSDictionary advertisementData, global::Foundation.NSNumber RSSI)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> _failedToConnectPeripheral = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals)> _retrievedConnectedPeripherals = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals)> _retrievedPeripherals = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _updatedState = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::Foundation.NSDictionary dict)> _willRestoreState = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::Foundation.NSDictionary dict)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral)> ConnectedPeripheralObs => _connectedPeripheral; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBConnectionEvent connectionEvent, global::CoreBluetooth.CBPeripheral peripheral)> ConnectionEventDidOccurObs => _connectionEventDidOccur; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral)> DidUpdateAncsAuthorizationObs => _didUpdateAncsAuthorization; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> DisconnectedPeripheralObs => _disconnectedPeripheral; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSDictionary advertisementData, global::Foundation.NSNumber RSSI)> DiscoveredPeripheralObs => _discoveredPeripheral; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> FailedToConnectPeripheralObs => _failedToConnectPeripheral; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals)> RetrievedConnectedPeripheralsObs => _retrievedConnectedPeripherals; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals)> RetrievedPeripheralsObs => _retrievedPeripherals; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UpdatedStateObs => _updatedState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::Foundation.NSDictionary dict)> WillRestoreStateObs => _willRestoreState; + /// + public override void ConnectedPeripheral(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral) => _connectedPeripheral.OnNext((central, peripheral)); + /// + public override void ConnectionEventDidOccur(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBConnectionEvent connectionEvent, global::CoreBluetooth.CBPeripheral peripheral) => _connectionEventDidOccur.OnNext((central, connectionEvent, peripheral)); + /// + public override void DidUpdateAncsAuthorization(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral) => _didUpdateAncsAuthorization.OnNext((central, peripheral)); + /// + public override void DisconnectedPeripheral(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error) => _disconnectedPeripheral.OnNext((central, peripheral, error)); + /// + public override void DiscoveredPeripheral(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSDictionary advertisementData, global::Foundation.NSNumber RSSI) => _discoveredPeripheral.OnNext((central, peripheral, advertisementData, RSSI)); + /// + public override void FailedToConnectPeripheral(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error) => _failedToConnectPeripheral.OnNext((central, peripheral, error)); + /// + public override void RetrievedConnectedPeripherals(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals) => _retrievedConnectedPeripherals.OnNext((central, peripherals)); + /// + public override void RetrievedPeripherals(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals) => _retrievedPeripherals.OnNext((central, peripherals)); + /// + public override void UpdatedState(global::CoreBluetooth.CBCentralManager central) => _updatedState.OnNext(central); + /// + public override void WillRestoreState(global::CoreBluetooth.CBCentralManager central, global::Foundation.NSDictionary dict) => _willRestoreState.OnNext((central, dict)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class CBPeripheralDelegateRx : global::CoreBluetooth.CBPeripheralDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)> _didOpenL2CapChannel = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> _discoveredCharacteristic = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> _discoveredDescriptor = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> _discoveredIncludedService = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> _discoveredService = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _invalidatedService = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _isReadyToSendWriteWithoutResponse = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService[] services)> _modifiedServices = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService[] services)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSNumber rssi, global::Foundation.NSError error)> _rssiRead = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSNumber rssi, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> _rssiUpdated = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> _updatedCharacterteristicValue = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _updatedName = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> _updatedNotificationState = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)> _updatedValue = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> _wroteCharacteristicValue = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)> _wroteDescriptorValue = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)> DidOpenL2CapChannelObs => _didOpenL2CapChannel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> DiscoveredCharacteristicObs => _discoveredCharacteristic; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> DiscoveredDescriptorObs => _discoveredDescriptor; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> DiscoveredIncludedServiceObs => _discoveredIncludedService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> DiscoveredServiceObs => _discoveredService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable InvalidatedServiceObs => _invalidatedService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable IsReadyToSendWriteWithoutResponseObs => _isReadyToSendWriteWithoutResponse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService[] services)> ModifiedServicesObs => _modifiedServices; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSNumber rssi, global::Foundation.NSError error)> RssiReadObs => _rssiRead; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> RssiUpdatedObs => _rssiUpdated; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> UpdatedCharacterteristicValueObs => _updatedCharacterteristicValue; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UpdatedNameObs => _updatedName; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> UpdatedNotificationStateObs => _updatedNotificationState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)> UpdatedValueObs => _updatedValue; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> WroteCharacteristicValueObs => _wroteCharacteristicValue; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)> WroteDescriptorValueObs => _wroteDescriptorValue; + /// + public override void DidOpenL2CapChannel(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error) => _didOpenL2CapChannel.OnNext((peripheral, channel, error)); + /// + public override void DiscoveredCharacteristic(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error) => _discoveredCharacteristic.OnNext((peripheral, service, error)); + /// + public override void DiscoveredDescriptor(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error) => _discoveredDescriptor.OnNext((peripheral, characteristic, error)); + /// + public override void DiscoveredIncludedService(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error) => _discoveredIncludedService.OnNext((peripheral, service, error)); + /// + public override void DiscoveredService(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error) => _discoveredService.OnNext((peripheral, error)); + /// + public override void InvalidatedService(global::CoreBluetooth.CBPeripheral peripheral) => _invalidatedService.OnNext(peripheral); + /// + public override void IsReadyToSendWriteWithoutResponse(global::CoreBluetooth.CBPeripheral peripheral) => _isReadyToSendWriteWithoutResponse.OnNext(peripheral); + /// + public override void ModifiedServices(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService[] services) => _modifiedServices.OnNext((peripheral, services)); + /// + public override void RssiRead(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSNumber rssi, global::Foundation.NSError error) => _rssiRead.OnNext((peripheral, rssi, error)); + /// + public override void RssiUpdated(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error) => _rssiUpdated.OnNext((peripheral, error)); + /// + public override void UpdatedCharacterteristicValue(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error) => _updatedCharacterteristicValue.OnNext((peripheral, characteristic, error)); + /// + public override void UpdatedName(global::CoreBluetooth.CBPeripheral peripheral) => _updatedName.OnNext(peripheral); + /// + public override void UpdatedNotificationState(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error) => _updatedNotificationState.OnNext((peripheral, characteristic, error)); + /// + public override void UpdatedValue(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error) => _updatedValue.OnNext((peripheral, descriptor, error)); + /// + public override void WroteCharacteristicValue(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error) => _wroteCharacteristicValue.OnNext((peripheral, characteristic, error)); + /// + public override void WroteDescriptorValue(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error) => _wroteDescriptorValue.OnNext((peripheral, descriptor, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CBPeripheralManagerDelegateRx : global::CoreBluetooth.CBPeripheralManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSError error)> _advertisingStarted = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)> _characteristicSubscribed = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)> _characteristicUnsubscribed = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)> _didOpenL2CapChannel = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)> _didPublishL2CapChannel = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)> _didUnpublishL2CapChannel = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest request)> _readRequestReceived = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest request)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _readyToUpdateSubscribers = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> _serviceAdded = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _stateUpdated = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSDictionary dict)> _willRestoreState = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSDictionary dict)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest[] requests)> _writeRequestsReceived = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest[] requests)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSError error)> AdvertisingStartedObs => _advertisingStarted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)> CharacteristicSubscribedObs => _characteristicSubscribed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)> CharacteristicUnsubscribedObs => _characteristicUnsubscribed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)> DidOpenL2CapChannelObs => _didOpenL2CapChannel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)> DidPublishL2CapChannelObs => _didPublishL2CapChannel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)> DidUnpublishL2CapChannelObs => _didUnpublishL2CapChannel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest request)> ReadRequestReceivedObs => _readRequestReceived; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ReadyToUpdateSubscribersObs => _readyToUpdateSubscribers; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> ServiceAddedObs => _serviceAdded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable StateUpdatedObs => _stateUpdated; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSDictionary dict)> WillRestoreStateObs => _willRestoreState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest[] requests)> WriteRequestsReceivedObs => _writeRequestsReceived; + /// + public override void AdvertisingStarted(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSError error) => _advertisingStarted.OnNext((peripheral, error)); + /// + public override void CharacteristicSubscribed(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic) => _characteristicSubscribed.OnNext((peripheral, central, characteristic)); + /// + public override void CharacteristicUnsubscribed(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic) => _characteristicUnsubscribed.OnNext((peripheral, central, characteristic)); + /// + public override void DidOpenL2CapChannel(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error) => _didOpenL2CapChannel.OnNext((peripheral, channel, error)); + /// + public override void DidPublishL2CapChannel(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error) => _didPublishL2CapChannel.OnNext((peripheral, psm, error)); + /// + public override void DidUnpublishL2CapChannel(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error) => _didUnpublishL2CapChannel.OnNext((peripheral, psm, error)); + /// + public override void ReadRequestReceived(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest request) => _readRequestReceived.OnNext((peripheral, request)); + /// + public override void ReadyToUpdateSubscribers(global::CoreBluetooth.CBPeripheralManager peripheral) => _readyToUpdateSubscribers.OnNext(peripheral); + /// + public override void ServiceAdded(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error) => _serviceAdded.OnNext((peripheral, service, error)); + /// + public override void StateUpdated(global::CoreBluetooth.CBPeripheralManager peripheral) => _stateUpdated.OnNext(peripheral); + /// + public override void WillRestoreState(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSDictionary dict) => _willRestoreState.OnNext((peripheral, dict)); + /// + public override void WriteRequestsReceived(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest[] requests) => _writeRequestsReceived.OnNext((peripheral, requests)); + } +} + +namespace CoreData +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSCoreDataCoreSpotlightDelegateRx : global::CoreData.NSCoreDataCoreSpotlightDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler)> _reindexAllSearchableItems = new Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler)> _reindexSearchableItems = new Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler)> ReindexAllSearchableItemsObs => _reindexAllSearchableItems; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler)> ReindexSearchableItemsObs => _reindexSearchableItems; + /// + public override void ReindexAllSearchableItems(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler) => _reindexAllSearchableItems.OnNext((searchableIndex, acknowledgementHandler)); + /// + public override void ReindexSearchableItems(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler) => _reindexSearchableItems.OnNext((searchableIndex, identifiers, acknowledgementHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSFetchedResultsControllerDelegateRx : global::CoreData.NSFetchedResultsControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeContent = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreData.NSFetchedResultsController controller, global::Foundation.NSObject anObject, global::Foundation.NSIndexPath indexPath, global::CoreData.NSFetchedResultsChangeType type, global::Foundation.NSIndexPath newIndexPath)> _didChangeObject = new Pharmacist.Common.SingleAwaitSubject<(global::CoreData.NSFetchedResultsController controller, global::Foundation.NSObject anObject, global::Foundation.NSIndexPath indexPath, global::CoreData.NSFetchedResultsChangeType type, global::Foundation.NSIndexPath newIndexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreData.NSFetchedResultsController controller, global::CoreData.INSFetchedResultsSectionInfo sectionInfo, global::System.nuint sectionIndex, global::CoreData.NSFetchedResultsChangeType type)> _didChangeSection = new Pharmacist.Common.SingleAwaitSubject<(global::CoreData.NSFetchedResultsController controller, global::CoreData.INSFetchedResultsSectionInfo sectionInfo, global::System.nuint sectionIndex, global::CoreData.NSFetchedResultsChangeType type)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willChangeContent = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeContentObs => _didChangeContent; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreData.NSFetchedResultsController controller, global::Foundation.NSObject anObject, global::Foundation.NSIndexPath indexPath, global::CoreData.NSFetchedResultsChangeType type, global::Foundation.NSIndexPath newIndexPath)> DidChangeObjectObs => _didChangeObject; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreData.NSFetchedResultsController controller, global::CoreData.INSFetchedResultsSectionInfo sectionInfo, global::System.nuint sectionIndex, global::CoreData.NSFetchedResultsChangeType type)> DidChangeSectionObs => _didChangeSection; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillChangeContentObs => _willChangeContent; + /// + public override void DidChangeContent(global::CoreData.NSFetchedResultsController controller) => _didChangeContent.OnNext(controller); + /// + public override void DidChangeObject(global::CoreData.NSFetchedResultsController controller, global::Foundation.NSObject anObject, global::Foundation.NSIndexPath indexPath, global::CoreData.NSFetchedResultsChangeType type, global::Foundation.NSIndexPath newIndexPath) => _didChangeObject.OnNext((controller, anObject, indexPath, type, newIndexPath)); + /// + public override void DidChangeSection(global::CoreData.NSFetchedResultsController controller, global::CoreData.INSFetchedResultsSectionInfo sectionInfo, global::System.nuint sectionIndex, global::CoreData.NSFetchedResultsChangeType type) => _didChangeSection.OnNext((controller, sectionInfo, sectionIndex, type)); + /// + public override void WillChangeContent(global::CoreData.NSFetchedResultsController controller) => _willChangeContent.OnNext(controller); + } +} + +namespace CoreLocation +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class CLLocationManagerDelegateRx : global::CoreLocation.CLLocationManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLAuthorizationStatus status)> _authorizationChanged = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLAuthorizationStatus status)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error)> _deferredUpdatesFinished = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeAuthorization = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegionState state, global::CoreLocation.CLRegion region)> _didDetermineState = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegionState state, global::CoreLocation.CLRegion region)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint, global::Foundation.NSError error)> _didFailRangingBeacons = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeacon[] beacons, global::CoreLocation.CLBeaconRegion region)> _didRangeBeacons = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeacon[] beacons, global::CoreLocation.CLBeaconRegion region)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeacon[] beacons, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint)> _didRangeBeaconsSatisfyingConstraint = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeacon[] beacons, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)> _didStartMonitoringForRegion = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLVisit visit)> _didVisit = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLVisit visit)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error)> _failed = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation[] locations)> _locationsUpdated = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation[] locations)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _locationUpdatesPaused = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _locationUpdatesResumed = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region, global::Foundation.NSError error)> _monitoringFailed = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeaconRegion region, global::Foundation.NSError error)> _rangingBeaconsDidFailForRegion = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeaconRegion region, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)> _regionEntered = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)> _regionLeft = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLHeading newHeading)> _updatedHeading = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLHeading newHeading)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation newLocation, global::CoreLocation.CLLocation oldLocation)> _updatedLocation = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation newLocation, global::CoreLocation.CLLocation oldLocation)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLAuthorizationStatus status)> AuthorizationChangedObs => _authorizationChanged; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error)> DeferredUpdatesFinishedObs => _deferredUpdatesFinished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeAuthorizationObs => _didChangeAuthorization; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegionState state, global::CoreLocation.CLRegion region)> DidDetermineStateObs => _didDetermineState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint, global::Foundation.NSError error)> DidFailRangingBeaconsObs => _didFailRangingBeacons; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeacon[] beacons, global::CoreLocation.CLBeaconRegion region)> DidRangeBeaconsObs => _didRangeBeacons; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeacon[] beacons, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint)> DidRangeBeaconsSatisfyingConstraintObs => _didRangeBeaconsSatisfyingConstraint; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)> DidStartMonitoringForRegionObs => _didStartMonitoringForRegion; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLVisit visit)> DidVisitObs => _didVisit; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error)> FailedObs => _failed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation[] locations)> LocationsUpdatedObs => _locationsUpdated; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LocationUpdatesPausedObs => _locationUpdatesPaused; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LocationUpdatesResumedObs => _locationUpdatesResumed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region, global::Foundation.NSError error)> MonitoringFailedObs => _monitoringFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeaconRegion region, global::Foundation.NSError error)> RangingBeaconsDidFailForRegionObs => _rangingBeaconsDidFailForRegion; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)> RegionEnteredObs => _regionEntered; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)> RegionLeftObs => _regionLeft; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLHeading newHeading)> UpdatedHeadingObs => _updatedHeading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation newLocation, global::CoreLocation.CLLocation oldLocation)> UpdatedLocationObs => _updatedLocation; + /// + public override void AuthorizationChanged(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLAuthorizationStatus status) => _authorizationChanged.OnNext((manager, status)); + /// + public override void DeferredUpdatesFinished(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error) => _deferredUpdatesFinished.OnNext((manager, error)); + /// + public override void DidChangeAuthorization(global::CoreLocation.CLLocationManager manager) => _didChangeAuthorization.OnNext(manager); + /// + public override void DidDetermineState(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegionState state, global::CoreLocation.CLRegion region) => _didDetermineState.OnNext((manager, state, region)); + /// + public override void DidFailRangingBeacons(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint, global::Foundation.NSError error) => _didFailRangingBeacons.OnNext((manager, beaconConstraint, error)); + /// + public override void DidRangeBeacons(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeacon[] beacons, global::CoreLocation.CLBeaconRegion region) => _didRangeBeacons.OnNext((manager, beacons, region)); + /// + public override void DidRangeBeaconsSatisfyingConstraint(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeacon[] beacons, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint) => _didRangeBeaconsSatisfyingConstraint.OnNext((manager, beacons, beaconConstraint)); + /// + public override void DidStartMonitoringForRegion(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region) => _didStartMonitoringForRegion.OnNext((manager, region)); + /// + public override void DidVisit(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLVisit visit) => _didVisit.OnNext((manager, visit)); + /// + public override void Failed(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error) => _failed.OnNext((manager, error)); + /// + public override void LocationsUpdated(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation[] locations) => _locationsUpdated.OnNext((manager, locations)); + /// + public override void LocationUpdatesPaused(global::CoreLocation.CLLocationManager manager) => _locationUpdatesPaused.OnNext(manager); + /// + public override void LocationUpdatesResumed(global::CoreLocation.CLLocationManager manager) => _locationUpdatesResumed.OnNext(manager); + /// + public override void MonitoringFailed(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region, global::Foundation.NSError error) => _monitoringFailed.OnNext((manager, region, error)); + /// + public override void RangingBeaconsDidFailForRegion(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeaconRegion region, global::Foundation.NSError error) => _rangingBeaconsDidFailForRegion.OnNext((manager, region, error)); + /// + public override void RegionEntered(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region) => _regionEntered.OnNext((manager, region)); + /// + public override void RegionLeft(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region) => _regionLeft.OnNext((manager, region)); + /// + public override void UpdatedHeading(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLHeading newHeading) => _updatedHeading.OnNext((manager, newHeading)); + /// + public override void UpdatedLocation(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation newLocation, global::CoreLocation.CLLocation oldLocation) => _updatedLocation.OnNext((manager, newLocation, oldLocation)); + } +} + +namespace CoreMidi +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class MidiCIProfileResponderDelegateRx : global::CoreMidi.MidiCIProfileResponderDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreMidi.MidiCIProfile profile, byte channel, global::Foundation.NSData inData)> _handleData = new Pharmacist.Common.SingleAwaitSubject<(global::CoreMidi.MidiCIProfile profile, byte channel, global::Foundation.NSData inData)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _initiatorDisconnected = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreMidi.MidiCIProfile profile, byte channel, global::Foundation.NSData inData)> HandleDataObs => _handleData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable InitiatorDisconnectedObs => _initiatorDisconnected; + /// + public override void HandleData(global::CoreMidi.MidiCIProfile profile, byte channel, global::Foundation.NSData inData) => _handleData.OnNext((profile, channel, inData)); + /// + public override void InitiatorDisconnected(global::Foundation.NSNumber initiatorMuid) => _initiatorDisconnected.OnNext(initiatorMuid); + } +} + +namespace CoreMotion +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class CMHeadphoneMotionManagerDelegateRx : global::CoreMotion.CMHeadphoneMotionManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didConnect = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didDisconnect = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidConnectObs => _didConnect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDisconnectObs => _didDisconnect; + /// + public override void DidConnect(global::CoreMotion.CMHeadphoneMotionManager manager) => _didConnect.OnNext(manager); + /// + public override void DidDisconnect(global::CoreMotion.CMHeadphoneMotionManager manager) => _didDisconnect.OnNext(manager); + } +} + +namespace CoreNFC +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NFCNdefReaderSessionDelegateRx : global::CoreNFC.NFCNdefReaderSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeActive = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCNdefReaderSession session, global::CoreNFC.NFCNdefMessage[] messages)> _didDetect = new Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCNdefReaderSession session, global::CoreNFC.NFCNdefMessage[] messages)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCNdefReaderSession session, global::CoreNFC.INFCNdefTag[] tags)> _didDetectTags = new Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCNdefReaderSession session, global::CoreNFC.INFCNdefTag[] tags)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCNdefReaderSession session, global::Foundation.NSError error)> _didInvalidate = new Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCNdefReaderSession session, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeActiveObs => _didBecomeActive; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreNFC.NFCNdefReaderSession session, global::CoreNFC.NFCNdefMessage[] messages)> DidDetectObs => _didDetect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreNFC.NFCNdefReaderSession session, global::CoreNFC.INFCNdefTag[] tags)> DidDetectTagsObs => _didDetectTags; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreNFC.NFCNdefReaderSession session, global::Foundation.NSError error)> DidInvalidateObs => _didInvalidate; + /// + public override void DidBecomeActive(global::CoreNFC.NFCNdefReaderSession session) => _didBecomeActive.OnNext(session); + /// + public override void DidDetect(global::CoreNFC.NFCNdefReaderSession session, global::CoreNFC.NFCNdefMessage[] messages) => _didDetect.OnNext((session, messages)); + /// + public override void DidDetectTags(global::CoreNFC.NFCNdefReaderSession session, global::CoreNFC.INFCNdefTag[] tags) => _didDetectTags.OnNext((session, tags)); + /// + public override void DidInvalidate(global::CoreNFC.NFCNdefReaderSession session, global::Foundation.NSError error) => _didInvalidate.OnNext((session, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NFCReaderSessionDelegateRx : global::CoreNFC.NFCReaderSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeActive = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCReaderSession session, global::CoreNFC.INFCTag[] tags)> _didDetectTags = new Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCReaderSession session, global::CoreNFC.INFCTag[] tags)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCReaderSession session, global::Foundation.NSError error)> _didInvalidate = new Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCReaderSession session, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeActiveObs => _didBecomeActive; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreNFC.NFCReaderSession session, global::CoreNFC.INFCTag[] tags)> DidDetectTagsObs => _didDetectTags; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreNFC.NFCReaderSession session, global::Foundation.NSError error)> DidInvalidateObs => _didInvalidate; + /// + public override void DidBecomeActive(global::CoreNFC.NFCReaderSession session) => _didBecomeActive.OnNext(session); + /// + public override void DidDetectTags(global::CoreNFC.NFCReaderSession session, global::CoreNFC.INFCTag[] tags) => _didDetectTags.OnNext((session, tags)); + /// + public override void DidInvalidate(global::CoreNFC.NFCReaderSession session, global::Foundation.NSError error) => _didInvalidate.OnNext((session, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NFCTagReaderSessionDelegateRx : global::CoreNFC.NFCTagReaderSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeActive = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCTagReaderSession session, global::CoreNFC.INFCTag[] tags)> _didDetectTags = new Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCTagReaderSession session, global::CoreNFC.INFCTag[] tags)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCTagReaderSession session, global::Foundation.NSError error)> _didInvalidate = new Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCTagReaderSession session, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeActiveObs => _didBecomeActive; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreNFC.NFCTagReaderSession session, global::CoreNFC.INFCTag[] tags)> DidDetectTagsObs => _didDetectTags; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreNFC.NFCTagReaderSession session, global::Foundation.NSError error)> DidInvalidateObs => _didInvalidate; + /// + public override void DidBecomeActive(global::CoreNFC.NFCTagReaderSession session) => _didBecomeActive.OnNext(session); + /// + public override void DidDetectTags(global::CoreNFC.NFCTagReaderSession session, global::CoreNFC.INFCTag[] tags) => _didDetectTags.OnNext((session, tags)); + /// + public override void DidInvalidate(global::CoreNFC.NFCTagReaderSession session, global::Foundation.NSError error) => _didInvalidate.OnNext((session, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NFCVasReaderSessionDelegateRx : global::CoreNFC.NFCVasReaderSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeActive = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCVasReaderSession session, global::Foundation.NSError error)> _didInvalidate = new Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCVasReaderSession session, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCVasReaderSession session, global::CoreNFC.NFCVasResponse[] responses)> _didReceiveVasResponses = new Pharmacist.Common.SingleAwaitSubject<(global::CoreNFC.NFCVasReaderSession session, global::CoreNFC.NFCVasResponse[] responses)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeActiveObs => _didBecomeActive; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreNFC.NFCVasReaderSession session, global::Foundation.NSError error)> DidInvalidateObs => _didInvalidate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreNFC.NFCVasReaderSession session, global::CoreNFC.NFCVasResponse[] responses)> DidReceiveVasResponsesObs => _didReceiveVasResponses; + /// + public override void DidBecomeActive(global::CoreNFC.NFCVasReaderSession session) => _didBecomeActive.OnNext(session); + /// + public override void DidInvalidate(global::CoreNFC.NFCVasReaderSession session, global::Foundation.NSError error) => _didInvalidate.OnNext((session, error)); + /// + public override void DidReceiveVasResponses(global::CoreNFC.NFCVasReaderSession session, global::CoreNFC.NFCVasResponse[] responses) => _didReceiveVasResponses.OnNext((session, responses)); + } +} + +namespace CoreSpotlight +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CSSearchableIndexDelegateRx : global::CoreSpotlight.CSSearchableIndexDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didFinishThrottle = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didThrottle = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler)> _reindexAllSearchableItems = new Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler)> _reindexSearchableItems = new Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishThrottleObs => _didFinishThrottle; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidThrottleObs => _didThrottle; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler)> ReindexAllSearchableItemsObs => _reindexAllSearchableItems; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler)> ReindexSearchableItemsObs => _reindexSearchableItems; + /// + public override void DidFinishThrottle(global::CoreSpotlight.CSSearchableIndex searchableIndex) => _didFinishThrottle.OnNext(searchableIndex); + /// + public override void DidThrottle(global::CoreSpotlight.CSSearchableIndex searchableIndex) => _didThrottle.OnNext(searchableIndex); + /// + public override void ReindexAllSearchableItems(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler) => _reindexAllSearchableItems.OnNext((searchableIndex, acknowledgementHandler)); + /// + public override void ReindexSearchableItems(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler) => _reindexSearchableItems.OnNext((searchableIndex, identifiers, acknowledgementHandler)); + } +} + +namespace CoreTelephony +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class CTTelephonyNetworkInfoDelegateRx : global::CoreTelephony.CTTelephonyNetworkInfoDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _dataServiceIdentifierDidChange = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DataServiceIdentifierDidChangeObs => _dataServiceIdentifierDidChange; + /// + public override void DataServiceIdentifierDidChange(string identifier) => _dataServiceIdentifierDidChange.OnNext(identifier); + } +} + +namespace EventKitUI +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class EKCalendarChooserDelegateRx : global::EventKitUI.EKCalendarChooserDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _cancelled = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _finished = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _selectionChanged = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable CancelledObs => _cancelled; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedObs => _finished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SelectionChangedObs => _selectionChanged; + /// + public override void Cancelled(global::EventKitUI.EKCalendarChooser calendarChooser) => _cancelled.OnNext(calendarChooser); + /// + public override void Finished(global::EventKitUI.EKCalendarChooser calendarChooser) => _finished.OnNext(calendarChooser); + /// + public override void SelectionChanged(global::EventKitUI.EKCalendarChooser calendarChooser) => _selectionChanged.OnNext(calendarChooser); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class EKEventEditViewDelegateRx : global::EventKitUI.EKEventEditViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::EventKitUI.EKEventEditViewController controller, global::EventKitUI.EKEventEditViewAction action)> _completed = new Pharmacist.Common.SingleAwaitSubject<(global::EventKitUI.EKEventEditViewController controller, global::EventKitUI.EKEventEditViewAction action)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::EventKitUI.EKEventEditViewController controller, global::EventKitUI.EKEventEditViewAction action)> CompletedObs => _completed; + /// + public override void Completed(global::EventKitUI.EKEventEditViewController controller, global::EventKitUI.EKEventEditViewAction action) => _completed.OnNext((controller, action)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class EKEventViewDelegateRx : global::EventKitUI.EKEventViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::EventKitUI.EKEventViewController controller, global::EventKitUI.EKEventViewAction action)> _completed = new Pharmacist.Common.SingleAwaitSubject<(global::EventKitUI.EKEventViewController controller, global::EventKitUI.EKEventViewAction action)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::EventKitUI.EKEventViewController controller, global::EventKitUI.EKEventViewAction action)> CompletedObs => _completed; + /// + public override void Completed(global::EventKitUI.EKEventViewController controller, global::EventKitUI.EKEventViewAction action) => _completed.OnNext((controller, action)); + } +} + +namespace ExternalAccessory +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class EAAccessoryDelegateRx : global::ExternalAccessory.EAAccessoryDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _disconnected = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DisconnectedObs => _disconnected; + /// + public override void Disconnected(global::ExternalAccessory.EAAccessory accessory) => _disconnected.OnNext(accessory); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class EAWiFiUnconfiguredAccessoryBrowserDelegateRx : global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowserDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::Foundation.NSSet accessories)> _didFindUnconfiguredAccessories = new Pharmacist.Common.SingleAwaitSubject<(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::Foundation.NSSet accessories)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::ExternalAccessory.EAWiFiUnconfiguredAccessory accessory, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryConfigurationStatus status)> _didFinishConfiguringAccessory = new Pharmacist.Common.SingleAwaitSubject<(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::ExternalAccessory.EAWiFiUnconfiguredAccessory accessory, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryConfigurationStatus status)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::Foundation.NSSet accessories)> _didRemoveUnconfiguredAccessories = new Pharmacist.Common.SingleAwaitSubject<(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::Foundation.NSSet accessories)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowserState state)> _didUpdateState = new Pharmacist.Common.SingleAwaitSubject<(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowserState state)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::Foundation.NSSet accessories)> DidFindUnconfiguredAccessoriesObs => _didFindUnconfiguredAccessories; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::ExternalAccessory.EAWiFiUnconfiguredAccessory accessory, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryConfigurationStatus status)> DidFinishConfiguringAccessoryObs => _didFinishConfiguringAccessory; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::Foundation.NSSet accessories)> DidRemoveUnconfiguredAccessoriesObs => _didRemoveUnconfiguredAccessories; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowserState state)> DidUpdateStateObs => _didUpdateState; + /// + public override void DidFindUnconfiguredAccessories(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::Foundation.NSSet accessories) => _didFindUnconfiguredAccessories.OnNext((browser, accessories)); + /// + public override void DidFinishConfiguringAccessory(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::ExternalAccessory.EAWiFiUnconfiguredAccessory accessory, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryConfigurationStatus status) => _didFinishConfiguringAccessory.OnNext((browser, accessory, status)); + /// + public override void DidRemoveUnconfiguredAccessories(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::Foundation.NSSet accessories) => _didRemoveUnconfiguredAccessories.OnNext((browser, accessories)); + /// + public override void DidUpdateState(global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowser browser, global::ExternalAccessory.EAWiFiUnconfiguredAccessoryBrowserState state) => _didUpdateState.OnNext((browser, state)); + } +} + +namespace Foundation +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSCacheDelegateRx : global::Foundation.NSCacheDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSCache cache, global::Foundation.NSObject obj)> _willEvictObject = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSCache cache, global::Foundation.NSObject obj)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSCache cache, global::Foundation.NSObject obj)> WillEvictObjectObs => _willEvictObject; + /// + public override void WillEvictObject(global::Foundation.NSCache cache, global::Foundation.NSObject obj) => _willEvictObject.OnNext((cache, obj)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSKeyedArchiverDelegateRx : global::Foundation.NSKeyedArchiverDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject obj)> _encodedObject = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject obj)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _finished = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _finishing = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)> _replacingObject = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject obj)> EncodedObjectObs => _encodedObject; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedObs => _finished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishingObs => _finishing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)> ReplacingObjectObs => _replacingObject; + /// + public override void EncodedObject(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject obj) => _encodedObject.OnNext((archiver, obj)); + /// + public override void Finished(global::Foundation.NSKeyedArchiver archiver) => _finished.OnNext(archiver); + /// + public override void Finishing(global::Foundation.NSKeyedArchiver archiver) => _finishing.OnNext(archiver); + /// + public override void ReplacingObject(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject) => _replacingObject.OnNext((archiver, oldObject, newObject)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSKeyedUnarchiverDelegateRx : global::Foundation.NSKeyedUnarchiverDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _finished = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _finishing = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedUnarchiver unarchiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)> _replacingObject = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedUnarchiver unarchiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedObs => _finished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishingObs => _finishing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSKeyedUnarchiver unarchiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)> ReplacingObjectObs => _replacingObject; + /// + public override void Finished(global::Foundation.NSKeyedUnarchiver unarchiver) => _finished.OnNext(unarchiver); + /// + public override void Finishing(global::Foundation.NSKeyedUnarchiver unarchiver) => _finishing.OnNext(unarchiver); + /// + public override void ReplacingObject(global::Foundation.NSKeyedUnarchiver unarchiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject) => _replacingObject.OnNext((unarchiver, oldObject, newObject)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSMachPortDelegateRx : global::Foundation.NSMachPortDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _machMessageReceived = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable MachMessageReceivedObs => _machMessageReceived; + /// + public override void MachMessageReceived(global::System.IntPtr msgHeader) => _machMessageReceived.OnNext(msgHeader); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSNetServiceBrowserDelegateRx : global::Foundation.NSNetServiceBrowserDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing)> _domainRemoved = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing)> _foundDomain = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing)> _foundService = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSDictionary errors)> _notSearched = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSDictionary errors)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _searchStarted = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _searchStopped = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing)> _serviceRemoved = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing)> DomainRemovedObs => _domainRemoved; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing)> FoundDomainObs => _foundDomain; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing)> FoundServiceObs => _foundService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSDictionary errors)> NotSearchedObs => _notSearched; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SearchStartedObs => _searchStarted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SearchStoppedObs => _searchStopped; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing)> ServiceRemovedObs => _serviceRemoved; + /// + public override void DomainRemoved(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing) => _domainRemoved.OnNext((sender, domain, moreComing)); + /// + public override void FoundDomain(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing) => _foundDomain.OnNext((sender, domain, moreComing)); + /// + public override void FoundService(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing) => _foundService.OnNext((sender, service, moreComing)); + /// + public override void NotSearched(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSDictionary errors) => _notSearched.OnNext((sender, errors)); + /// + public override void SearchStarted(global::Foundation.NSNetServiceBrowser sender) => _searchStarted.OnNext(sender); + /// + public override void SearchStopped(global::Foundation.NSNetServiceBrowser sender) => _searchStopped.OnNext(sender); + /// + public override void ServiceRemoved(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing) => _serviceRemoved.OnNext((sender, service, moreComing)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSNetServiceDelegateRx : global::Foundation.NSNetServiceDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _addressResolved = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> _didAcceptConnection = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _published = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors)> _publishFailure = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors)> _resolveFailure = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _stopped = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSData data)> _updatedTxtRecordData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willPublish = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willResolve = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable AddressResolvedObs => _addressResolved; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetService sender, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> DidAcceptConnectionObs => _didAcceptConnection; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PublishedObs => _published; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors)> PublishFailureObs => _publishFailure; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors)> ResolveFailureObs => _resolveFailure; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable StoppedObs => _stopped; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetService sender, global::Foundation.NSData data)> UpdatedTxtRecordDataObs => _updatedTxtRecordData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillPublishObs => _willPublish; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillResolveObs => _willResolve; + /// + public override void AddressResolved(global::Foundation.NSNetService sender) => _addressResolved.OnNext(sender); + /// + public override void DidAcceptConnection(global::Foundation.NSNetService sender, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream) => _didAcceptConnection.OnNext((sender, inputStream, outputStream)); + /// + public override void Published(global::Foundation.NSNetService sender) => _published.OnNext(sender); + /// + public override void PublishFailure(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors) => _publishFailure.OnNext((sender, errors)); + /// + public override void ResolveFailure(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors) => _resolveFailure.OnNext((sender, errors)); + /// + public override void Stopped(global::Foundation.NSNetService sender) => _stopped.OnNext(sender); + /// + public override void UpdatedTxtRecordData(global::Foundation.NSNetService sender, global::Foundation.NSData data) => _updatedTxtRecordData.OnNext((sender, data)); + /// + public override void WillPublish(global::Foundation.NSNetService sender) => _willPublish.OnNext(sender); + /// + public override void WillResolve(global::Foundation.NSNetService sender) => _willResolve.OnNext(sender); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSPortDelegateRx : global::Foundation.NSPortDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _messageReceived = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable MessageReceivedObs => _messageReceived; + /// + public override void MessageReceived(global::Foundation.NSPortMessage message) => _messageReceived.OnNext(message); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSStreamDelegateRx : global::Foundation.NSStreamDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSStream theStream, global::Foundation.NSStreamEvent streamEvent)> _handleEvent = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSStream theStream, global::Foundation.NSStreamEvent streamEvent)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSStream theStream, global::Foundation.NSStreamEvent streamEvent)> HandleEventObs => _handleEvent; + /// + public override void HandleEvent(global::Foundation.NSStream theStream, global::Foundation.NSStreamEvent streamEvent) => _handleEvent.OnNext((theStream, streamEvent)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlConnectionDataDelegateRx : global::Foundation.NSUrlConnectionDataDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _finishedLoading = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSData data)> _receivedData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlResponse response)> _receivedResponse = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlResponse response)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::System.nint bytesWritten, global::System.nint totalBytesWritten, global::System.nint totalBytesExpectedToWrite)> _sentBodyData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::System.nint bytesWritten, global::System.nint totalBytesWritten, global::System.nint totalBytesExpectedToWrite)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedLoadingObs => _finishedLoading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSData data)> ReceivedDataObs => _receivedData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlResponse response)> ReceivedResponseObs => _receivedResponse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::System.nint bytesWritten, global::System.nint totalBytesWritten, global::System.nint totalBytesExpectedToWrite)> SentBodyDataObs => _sentBodyData; + /// + public override void FinishedLoading(global::Foundation.NSUrlConnection connection) => _finishedLoading.OnNext(connection); + /// + public override void ReceivedData(global::Foundation.NSUrlConnection connection, global::Foundation.NSData data) => _receivedData.OnNext((connection, data)); + /// + public override void ReceivedResponse(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlResponse response) => _receivedResponse.OnNext((connection, response)); + /// + public override void SentBodyData(global::Foundation.NSUrlConnection connection, global::System.nint bytesWritten, global::System.nint totalBytesWritten, global::System.nint totalBytesExpectedToWrite) => _sentBodyData.OnNext((connection, bytesWritten, totalBytesWritten, totalBytesExpectedToWrite)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlConnectionDelegateRx : global::Foundation.NSUrlConnectionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> _canceledAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSError error)> _failedWithError = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> _receivedAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> _willSendRequestForAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> CanceledAuthenticationChallengeObs => _canceledAuthenticationChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSError error)> FailedWithErrorObs => _failedWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> ReceivedAuthenticationChallengeObs => _receivedAuthenticationChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> WillSendRequestForAuthenticationChallengeObs => _willSendRequestForAuthenticationChallenge; + /// + public override void CanceledAuthenticationChallenge(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge) => _canceledAuthenticationChallenge.OnNext((connection, challenge)); + /// + public override void FailedWithError(global::Foundation.NSUrlConnection connection, global::Foundation.NSError error) => _failedWithError.OnNext((connection, error)); + /// + public override void ReceivedAuthenticationChallenge(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge) => _receivedAuthenticationChallenge.OnNext((connection, challenge)); + /// + public override void WillSendRequestForAuthenticationChallenge(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge) => _willSendRequestForAuthenticationChallenge.OnNext((connection, challenge)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NSUrlConnectionDownloadDelegateRx : global::Foundation.NSUrlConnectionDownloadDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrl destinationUrl)> _finishedDownloading = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrl destinationUrl)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, long totalBytesWritten, long expectedTotalBytes)> _resumedDownloading = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, long totalBytesWritten, long expectedTotalBytes)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, long bytesWritten, long totalBytesWritten, long expectedTotalBytes)> _wroteData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, long bytesWritten, long totalBytesWritten, long expectedTotalBytes)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrl destinationUrl)> FinishedDownloadingObs => _finishedDownloading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, long totalBytesWritten, long expectedTotalBytes)> ResumedDownloadingObs => _resumedDownloading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, long bytesWritten, long totalBytesWritten, long expectedTotalBytes)> WroteDataObs => _wroteData; + /// + public override void FinishedDownloading(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrl destinationUrl) => _finishedDownloading.OnNext((connection, destinationUrl)); + /// + public override void ResumedDownloading(global::Foundation.NSUrlConnection connection, long totalBytesWritten, long expectedTotalBytes) => _resumedDownloading.OnNext((connection, totalBytesWritten, expectedTotalBytes)); + /// + public override void WroteData(global::Foundation.NSUrlConnection connection, long bytesWritten, long totalBytesWritten, long expectedTotalBytes) => _wroteData.OnNext((connection, bytesWritten, totalBytesWritten, expectedTotalBytes)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlSessionDataDelegateRx : global::Foundation.NSUrlSessionDataDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionDownloadTask downloadTask)> _didBecomeDownloadTask = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionDownloadTask downloadTask)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionStreamTask streamTask)> _didBecomeStreamTask = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionStreamTask streamTask)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSData data)> _didReceiveData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlResponse response, global::System.Action completionHandler)> _didReceiveResponse = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlResponse response, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSCachedUrlResponse proposedResponse, global::System.Action completionHandler)> _willCacheResponse = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSCachedUrlResponse proposedResponse, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionDownloadTask downloadTask)> DidBecomeDownloadTaskObs => _didBecomeDownloadTask; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionStreamTask streamTask)> DidBecomeStreamTaskObs => _didBecomeStreamTask; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSData data)> DidReceiveDataObs => _didReceiveData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlResponse response, global::System.Action completionHandler)> DidReceiveResponseObs => _didReceiveResponse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSCachedUrlResponse proposedResponse, global::System.Action completionHandler)> WillCacheResponseObs => _willCacheResponse; + /// + public override void DidBecomeDownloadTask(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionDownloadTask downloadTask) => _didBecomeDownloadTask.OnNext((session, dataTask, downloadTask)); + /// + public override void DidBecomeStreamTask(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionStreamTask streamTask) => _didBecomeStreamTask.OnNext((session, dataTask, streamTask)); + /// + public override void DidReceiveData(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSData data) => _didReceiveData.OnNext((session, dataTask, data)); + /// + public override void DidReceiveResponse(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlResponse response, global::System.Action completionHandler) => _didReceiveResponse.OnNext((session, dataTask, response, completionHandler)); + /// + public override void WillCacheResponse(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSCachedUrlResponse proposedResponse, global::System.Action completionHandler) => _willCacheResponse.OnNext((session, dataTask, proposedResponse, completionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlSessionDelegateRx : global::Foundation.NSUrlSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSError error)> _didBecomeInvalid = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinishEventsForBackgroundSession = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> _didReceiveChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSError error)> DidBecomeInvalidObs => _didBecomeInvalid; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishEventsForBackgroundSessionObs => _didFinishEventsForBackgroundSession; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> DidReceiveChallengeObs => _didReceiveChallenge; + /// + public override void DidBecomeInvalid(global::Foundation.NSUrlSession session, global::Foundation.NSError error) => _didBecomeInvalid.OnNext((session, error)); + /// + public override void DidFinishEventsForBackgroundSession(global::Foundation.NSUrlSession session) => _didFinishEventsForBackgroundSession.OnNext(session); + /// + public override void DidReceiveChallenge(global::Foundation.NSUrlSession session, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler) => _didReceiveChallenge.OnNext((session, challenge, completionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NSUrlSessionDownloadDelegateRx : global::Foundation.NSUrlSessionDownloadDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, global::Foundation.NSUrl location)> _didFinishDownloading = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, global::Foundation.NSUrl location)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long resumeFileOffset, long expectedTotalBytes)> _didResume = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long resumeFileOffset, long expectedTotalBytes)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long bytesWritten, long totalBytesWritten, long totalBytesExpectedToWrite)> _didWriteData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long bytesWritten, long totalBytesWritten, long totalBytesExpectedToWrite)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, global::Foundation.NSUrl location)> DidFinishDownloadingObs => _didFinishDownloading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long resumeFileOffset, long expectedTotalBytes)> DidResumeObs => _didResume; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long bytesWritten, long totalBytesWritten, long totalBytesExpectedToWrite)> DidWriteDataObs => _didWriteData; + /// + public override void DidFinishDownloading(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, global::Foundation.NSUrl location) => _didFinishDownloading.OnNext((session, downloadTask, location)); + /// + public override void DidResume(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long resumeFileOffset, long expectedTotalBytes) => _didResume.OnNext((session, downloadTask, resumeFileOffset, expectedTotalBytes)); + /// + public override void DidWriteData(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long bytesWritten, long totalBytesWritten, long totalBytesExpectedToWrite) => _didWriteData.OnNext((session, downloadTask, bytesWritten, totalBytesWritten, totalBytesExpectedToWrite)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlSessionStreamDelegateRx : global::Foundation.NSUrlSessionStreamDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> _betterRouteDiscovered = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> _completedTaskCaptureStreams = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> _readClosed = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> _writeClosed = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> BetterRouteDiscoveredObs => _betterRouteDiscovered; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> CompletedTaskCaptureStreamsObs => _completedTaskCaptureStreams; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> ReadClosedObs => _readClosed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> WriteClosedObs => _writeClosed; + /// + public override void BetterRouteDiscovered(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask) => _betterRouteDiscovered.OnNext((session, streamTask)); + /// + public override void CompletedTaskCaptureStreams(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream) => _completedTaskCaptureStreams.OnNext((session, streamTask, inputStream, outputStream)); + /// + public override void ReadClosed(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask) => _readClosed.OnNext((session, streamTask)); + /// + public override void WriteClosed(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask) => _writeClosed.OnNext((session, streamTask)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlSessionTaskDelegateRx : global::Foundation.NSUrlSessionTaskDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error)> _didCompleteWithError = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics)> _didFinishCollectingMetrics = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> _didReceiveChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend)> _didSendBodyData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler)> _needNewBodyStream = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task)> _taskIsWaitingForConnectivity = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler)> _willBeginDelayedRequest = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler)> _willPerformHttpRedirection = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error)> DidCompleteWithErrorObs => _didCompleteWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics)> DidFinishCollectingMetricsObs => _didFinishCollectingMetrics; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> DidReceiveChallengeObs => _didReceiveChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend)> DidSendBodyDataObs => _didSendBodyData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler)> NeedNewBodyStreamObs => _needNewBodyStream; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task)> TaskIsWaitingForConnectivityObs => _taskIsWaitingForConnectivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler)> WillBeginDelayedRequestObs => _willBeginDelayedRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler)> WillPerformHttpRedirectionObs => _willPerformHttpRedirection; + /// + public override void DidCompleteWithError(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error) => _didCompleteWithError.OnNext((session, task, error)); + /// + public override void DidFinishCollectingMetrics(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics) => _didFinishCollectingMetrics.OnNext((session, task, metrics)); + /// + public override void DidReceiveChallenge(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler) => _didReceiveChallenge.OnNext((session, task, challenge, completionHandler)); + /// + public override void DidSendBodyData(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend) => _didSendBodyData.OnNext((session, task, bytesSent, totalBytesSent, totalBytesExpectedToSend)); + /// + public override void NeedNewBodyStream(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler) => _needNewBodyStream.OnNext((session, task, completionHandler)); + /// + public override void TaskIsWaitingForConnectivity(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task) => _taskIsWaitingForConnectivity.OnNext((session, task)); + /// + public override void WillBeginDelayedRequest(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler) => _willBeginDelayedRequest.OnNext((session, task, request, completionHandler)); + /// + public override void WillPerformHttpRedirection(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler) => _willPerformHttpRedirection.OnNext((session, task, response, newRequest, completionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlSessionWebSocketDelegateRx : global::Foundation.NSUrlSessionWebSocketDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, global::Foundation.NSUrlSessionWebSocketCloseCode closeCode, global::Foundation.NSData reason)> _didClose = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, global::Foundation.NSUrlSessionWebSocketCloseCode closeCode, global::Foundation.NSData reason)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, string protocol)> _didOpen = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, string protocol)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, global::Foundation.NSUrlSessionWebSocketCloseCode closeCode, global::Foundation.NSData reason)> DidCloseObs => _didClose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, string protocol)> DidOpenObs => _didOpen; + /// + public override void DidClose(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, global::Foundation.NSUrlSessionWebSocketCloseCode closeCode, global::Foundation.NSData reason) => _didClose.OnNext((session, webSocketTask, closeCode, reason)); + /// + public override void DidOpen(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, string protocol) => _didOpen.OnNext((session, webSocketTask, protocol)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUserActivityDelegateRx : global::Foundation.NSUserActivityDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUserActivity userActivity, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> _userActivityReceivedData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUserActivity userActivity, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _userActivityWasContinued = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _userActivityWillSave = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUserActivity userActivity, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> UserActivityReceivedDataObs => _userActivityReceivedData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UserActivityWasContinuedObs => _userActivityWasContinued; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UserActivityWillSaveObs => _userActivityWillSave; + /// + public override void UserActivityReceivedData(global::Foundation.NSUserActivity userActivity, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream) => _userActivityReceivedData.OnNext((userActivity, inputStream, outputStream)); + /// + public override void UserActivityWasContinued(global::Foundation.NSUserActivity userActivity) => _userActivityWasContinued.OnNext(userActivity); + /// + public override void UserActivityWillSave(global::Foundation.NSUserActivity userActivity) => _userActivityWillSave.OnNext(userActivity); + } +} + +namespace GameKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKAchievementViewControllerDelegateRx : global::GameKit.GKAchievementViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didFinish = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishObs => _didFinish; + /// + public override void DidFinish(global::GameKit.GKAchievementViewController viewController) => _didFinish.OnNext(viewController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class GKChallengeEventHandlerDelegateRx : global::GameKit.GKChallengeEventHandlerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _localPlayerCompletedChallenge = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _localPlayerReceivedChallenge = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _localPlayerSelectedChallenge = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _remotePlayerCompletedChallenge = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LocalPlayerCompletedChallengeObs => _localPlayerCompletedChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LocalPlayerReceivedChallengeObs => _localPlayerReceivedChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LocalPlayerSelectedChallengeObs => _localPlayerSelectedChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable RemotePlayerCompletedChallengeObs => _remotePlayerCompletedChallenge; + /// + public override void LocalPlayerCompletedChallenge(global::GameKit.GKChallenge challenge) => _localPlayerCompletedChallenge.OnNext(challenge); + /// + public override void LocalPlayerReceivedChallenge(global::GameKit.GKChallenge challenge) => _localPlayerReceivedChallenge.OnNext(challenge); + /// + public override void LocalPlayerSelectedChallenge(global::GameKit.GKChallenge challenge) => _localPlayerSelectedChallenge.OnNext(challenge); + /// + public override void RemotePlayerCompletedChallenge(global::GameKit.GKChallenge challenge) => _remotePlayerCompletedChallenge.OnNext(challenge); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKFriendRequestComposeViewControllerDelegateRx : global::GameKit.GKFriendRequestComposeViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didFinish = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishObs => _didFinish; + /// + public override void DidFinish(global::GameKit.GKFriendRequestComposeViewController viewController) => _didFinish.OnNext(viewController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKGameCenterControllerDelegateRx : global::GameKit.GKGameCenterControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _finished = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedObs => _finished; + /// + public override void Finished(global::GameKit.GKGameCenterViewController controller) => _finished.OnNext(controller); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKLeaderboardViewControllerDelegateRx : global::GameKit.GKLeaderboardViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didFinish = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishObs => _didFinish; + /// + public override void DidFinish(global::GameKit.GKLeaderboardViewController viewController) => _didFinish.OnNext(viewController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class GKMatchDelegateRx : global::GameKit.GKMatchDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSData data, string playerId)> _dataReceived = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSData data, string playerId)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer recipient, global::GameKit.GKPlayer player)> _dataReceivedForRecipient = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer recipient, global::GameKit.GKPlayer player)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer player)> _dataReceivedFromPlayer = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer player)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSError error)> _failed = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, string playerId, global::GameKit.GKPlayerConnectionState state)> _stateChanged = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, string playerId, global::GameKit.GKPlayerConnectionState state)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::GameKit.GKPlayer player, global::GameKit.GKPlayerConnectionState state)> _stateChangedForPlayer = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::GameKit.GKPlayer player, global::GameKit.GKPlayerConnectionState state)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatch match, global::Foundation.NSData data, string playerId)> DataReceivedObs => _dataReceived; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer recipient, global::GameKit.GKPlayer player)> DataReceivedForRecipientObs => _dataReceivedForRecipient; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer player)> DataReceivedFromPlayerObs => _dataReceivedFromPlayer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatch match, global::Foundation.NSError error)> FailedObs => _failed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatch match, string playerId, global::GameKit.GKPlayerConnectionState state)> StateChangedObs => _stateChanged; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatch match, global::GameKit.GKPlayer player, global::GameKit.GKPlayerConnectionState state)> StateChangedForPlayerObs => _stateChangedForPlayer; + /// + public override void DataReceived(global::GameKit.GKMatch match, global::Foundation.NSData data, string playerId) => _dataReceived.OnNext((match, data, playerId)); + /// + public override void DataReceivedForRecipient(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer recipient, global::GameKit.GKPlayer player) => _dataReceivedForRecipient.OnNext((match, data, recipient, player)); + /// + public override void DataReceivedFromPlayer(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer player) => _dataReceivedFromPlayer.OnNext((match, data, player)); + /// + public override void Failed(global::GameKit.GKMatch match, global::Foundation.NSError error) => _failed.OnNext((match, error)); + /// + public override void StateChanged(global::GameKit.GKMatch match, string playerId, global::GameKit.GKPlayerConnectionState state) => _stateChanged.OnNext((match, playerId, state)); + /// + public override void StateChangedForPlayer(global::GameKit.GKMatch match, global::GameKit.GKPlayer player, global::GameKit.GKPlayerConnectionState state) => _stateChangedForPlayer.OnNext((match, player, state)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKMatchmakerViewControllerDelegateRx : global::GameKit.GKMatchmakerViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::Foundation.NSError error)> _didFailWithError = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer[] playerIDs)> _didFindHostedPlayers = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer[] playerIDs)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKMatch match)> _didFindMatch = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKMatch match)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::System.String[] playerIDs)> _didFindPlayers = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::System.String[] playerIDs)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer playerID)> _hostedPlayerDidAccept = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer playerID)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, string playerID)> _receivedAcceptFromHostedPlayer = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, string playerID)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _wasCancelled = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatchmakerViewController viewController, global::Foundation.NSError error)> DidFailWithErrorObs => _didFailWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer[] playerIDs)> DidFindHostedPlayersObs => _didFindHostedPlayers; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKMatch match)> DidFindMatchObs => _didFindMatch; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatchmakerViewController viewController, global::System.String[] playerIDs)> DidFindPlayersObs => _didFindPlayers; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer playerID)> HostedPlayerDidAcceptObs => _hostedPlayerDidAccept; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatchmakerViewController viewController, string playerID)> ReceivedAcceptFromHostedPlayerObs => _receivedAcceptFromHostedPlayer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WasCancelledObs => _wasCancelled; + /// + public override void DidFailWithError(global::GameKit.GKMatchmakerViewController viewController, global::Foundation.NSError error) => _didFailWithError.OnNext((viewController, error)); + /// + public override void DidFindHostedPlayers(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer[] playerIDs) => _didFindHostedPlayers.OnNext((viewController, playerIDs)); + /// + public override void DidFindMatch(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKMatch match) => _didFindMatch.OnNext((viewController, match)); + /// + public override void DidFindPlayers(global::GameKit.GKMatchmakerViewController viewController, global::System.String[] playerIDs) => _didFindPlayers.OnNext((viewController, playerIDs)); + /// + public override void HostedPlayerDidAccept(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer playerID) => _hostedPlayerDidAccept.OnNext((viewController, playerID)); + /// + public override void ReceivedAcceptFromHostedPlayer(global::GameKit.GKMatchmakerViewController viewController, string playerID) => _receivedAcceptFromHostedPlayer.OnNext((viewController, playerID)); + /// + public override void WasCancelled(global::GameKit.GKMatchmakerViewController viewController) => _wasCancelled.OnNext(viewController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class GKPeerPickerControllerDelegateRx : global::GameKit.GKPeerPickerControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKPeerPickerController picker, global::GameKit.GKPeerPickerConnectionType type)> _connectionTypeSelected = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKPeerPickerController picker, global::GameKit.GKPeerPickerConnectionType type)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _controllerCancelled = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKPeerPickerController picker, string peerId, global::GameKit.GKSession toSession)> _peerConnected = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKPeerPickerController picker, string peerId, global::GameKit.GKSession toSession)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKPeerPickerController picker, global::GameKit.GKPeerPickerConnectionType type)> ConnectionTypeSelectedObs => _connectionTypeSelected; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ControllerCancelledObs => _controllerCancelled; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKPeerPickerController picker, string peerId, global::GameKit.GKSession toSession)> PeerConnectedObs => _peerConnected; + /// + public override void ConnectionTypeSelected(global::GameKit.GKPeerPickerController picker, global::GameKit.GKPeerPickerConnectionType type) => _connectionTypeSelected.OnNext((picker, type)); + /// + public override void ControllerCancelled(global::GameKit.GKPeerPickerController picker) => _controllerCancelled.OnNext(picker); + /// + public override void PeerConnected(global::GameKit.GKPeerPickerController picker, string peerId, global::GameKit.GKSession toSession) => _peerConnected.OnNext((picker, peerId, toSession)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class GKSessionDelegateRx : global::GameKit.GKSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, global::Foundation.NSError error)> _failedWithError = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, string peerID, global::GameKit.GKPeerConnectionState state)> _peerChangedState = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, string peerID, global::GameKit.GKPeerConnectionState state)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, string peerID, global::Foundation.NSError error)> _peerConnectionFailed = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, string peerID, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, string peerID)> _peerConnectionRequest = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, string peerID)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKSession session, global::Foundation.NSError error)> FailedWithErrorObs => _failedWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKSession session, string peerID, global::GameKit.GKPeerConnectionState state)> PeerChangedStateObs => _peerChangedState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKSession session, string peerID, global::Foundation.NSError error)> PeerConnectionFailedObs => _peerConnectionFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKSession session, string peerID)> PeerConnectionRequestObs => _peerConnectionRequest; + /// + public override void FailedWithError(global::GameKit.GKSession session, global::Foundation.NSError error) => _failedWithError.OnNext((session, error)); + /// + public override void PeerChangedState(global::GameKit.GKSession session, string peerID, global::GameKit.GKPeerConnectionState state) => _peerChangedState.OnNext((session, peerID, state)); + /// + public override void PeerConnectionFailed(global::GameKit.GKSession session, string peerID, global::Foundation.NSError error) => _peerConnectionFailed.OnNext((session, peerID, error)); + /// + public override void PeerConnectionRequest(global::GameKit.GKSession session, string peerID) => _peerConnectionRequest.OnNext((session, peerID)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKTurnBasedEventHandlerDelegateRx : global::GameKit.GKTurnBasedEventHandlerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _handleInviteFromGameCenter = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _handleMatchEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatch match, bool activated)> _handleTurnEvent = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatch match, bool activated)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _handleTurnEventForMatch = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable HandleInviteFromGameCenterObs => _handleInviteFromGameCenter; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable HandleMatchEndedObs => _handleMatchEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKTurnBasedMatch match, bool activated)> HandleTurnEventObs => _handleTurnEvent; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable HandleTurnEventForMatchObs => _handleTurnEventForMatch; + /// + public override void HandleInviteFromGameCenter(global::Foundation.NSString[] playersToInvite) => _handleInviteFromGameCenter.OnNext(playersToInvite); + /// + public override void HandleMatchEnded(global::GameKit.GKTurnBasedMatch match) => _handleMatchEnded.OnNext(match); + /// + public override void HandleTurnEvent(global::GameKit.GKTurnBasedMatch match, bool activated) => _handleTurnEvent.OnNext((match, activated)); + /// + public override void HandleTurnEventForMatch(global::GameKit.GKTurnBasedMatch match) => _handleTurnEventForMatch.OnNext(match); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKTurnBasedMatchmakerViewControllerDelegateRx : global::GameKit.GKTurnBasedMatchmakerViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::Foundation.NSError error)> _failedWithError = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match)> _foundMatch = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match)> _playerQuitForMatch = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _wasCancelled = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::Foundation.NSError error)> FailedWithErrorObs => _failedWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match)> FoundMatchObs => _foundMatch; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match)> PlayerQuitForMatchObs => _playerQuitForMatch; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WasCancelledObs => _wasCancelled; + /// + public override void FailedWithError(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::Foundation.NSError error) => _failedWithError.OnNext((viewController, error)); + /// + public override void FoundMatch(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match) => _foundMatch.OnNext((viewController, match)); + /// + public override void PlayerQuitForMatch(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match) => _playerQuitForMatch.OnNext((viewController, match)); + /// + public override void WasCancelled(global::GameKit.GKTurnBasedMatchmakerViewController viewController) => _wasCancelled.OnNext(viewController); + } +} + +namespace GameplayKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class GKAgentDelegateRx : global::GameplayKit.GKAgentDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _agentDidUpdate = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _agentWillUpdate = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable AgentDidUpdateObs => _agentDidUpdate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable AgentWillUpdateObs => _agentWillUpdate; + /// + public override void AgentDidUpdate(global::GameplayKit.GKAgent agent) => _agentDidUpdate.OnNext(agent); + /// + public override void AgentWillUpdate(global::GameplayKit.GKAgent agent) => _agentWillUpdate.OnNext(agent); + } +} + +namespace GLKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GLKViewControllerDelegateRx : global::GLKit.GLKViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _update = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GLKit.GLKViewController controller, bool pause)> _willPause = new Pharmacist.Common.SingleAwaitSubject<(global::GLKit.GLKViewController controller, bool pause)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UpdateObs => _update; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GLKit.GLKViewController controller, bool pause)> WillPauseObs => _willPause; + /// + public override void Update(global::GLKit.GLKViewController controller) => _update.OnNext(controller); + /// + public override void WillPause(global::GLKit.GLKViewController controller, bool pause) => _willPause.OnNext((controller, pause)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GLKViewDelegateRx : global::GLKit.GLKViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GLKit.GLKView view, global::CoreGraphics.CGRect rect)> _drawInRect = new Pharmacist.Common.SingleAwaitSubject<(global::GLKit.GLKView view, global::CoreGraphics.CGRect rect)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GLKit.GLKView view, global::CoreGraphics.CGRect rect)> DrawInRectObs => _drawInRect; + /// + public override void DrawInRect(global::GLKit.GLKView view, global::CoreGraphics.CGRect rect) => _drawInRect.OnNext((view, rect)); + } +} + +namespace HomeKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class HMAccessoryBrowserDelegateRx : global::HomeKit.HMAccessoryBrowserDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessoryBrowser browser, global::HomeKit.HMAccessory accessory)> _didFindNewAccessory = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessoryBrowser browser, global::HomeKit.HMAccessory accessory)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessoryBrowser browser, global::HomeKit.HMAccessory accessory)> _didRemoveNewAccessory = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessoryBrowser browser, global::HomeKit.HMAccessory accessory)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMAccessoryBrowser browser, global::HomeKit.HMAccessory accessory)> DidFindNewAccessoryObs => _didFindNewAccessory; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMAccessoryBrowser browser, global::HomeKit.HMAccessory accessory)> DidRemoveNewAccessoryObs => _didRemoveNewAccessory; + /// + public override void DidFindNewAccessory(global::HomeKit.HMAccessoryBrowser browser, global::HomeKit.HMAccessory accessory) => _didFindNewAccessory.OnNext((browser, accessory)); + /// + public override void DidRemoveNewAccessory(global::HomeKit.HMAccessoryBrowser browser, global::HomeKit.HMAccessory accessory) => _didRemoveNewAccessory.OnNext((browser, accessory)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class HMAccessoryDelegateRx : global::HomeKit.HMAccessoryDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile)> _didAddProfile = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile)> _didRemoveProfile = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service)> _didUpdateAssociatedServiceType = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, string firmwareVersion)> _didUpdateFirmwareVersion = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, string firmwareVersion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateName = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service)> _didUpdateNameForService = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateReachability = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateServices = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service, global::HomeKit.HMCharacteristic characteristic)> _didUpdateValueForCharacteristic = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service, global::HomeKit.HMCharacteristic characteristic)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile)> DidAddProfileObs => _didAddProfile; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile)> DidRemoveProfileObs => _didRemoveProfile; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service)> DidUpdateAssociatedServiceTypeObs => _didUpdateAssociatedServiceType; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMAccessory accessory, string firmwareVersion)> DidUpdateFirmwareVersionObs => _didUpdateFirmwareVersion; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateNameObs => _didUpdateName; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service)> DidUpdateNameForServiceObs => _didUpdateNameForService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateReachabilityObs => _didUpdateReachability; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateServicesObs => _didUpdateServices; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service, global::HomeKit.HMCharacteristic characteristic)> DidUpdateValueForCharacteristicObs => _didUpdateValueForCharacteristic; + /// + public override void DidAddProfile(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile) => _didAddProfile.OnNext((accessory, profile)); + /// + public override void DidRemoveProfile(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile) => _didRemoveProfile.OnNext((accessory, profile)); + /// + public override void DidUpdateAssociatedServiceType(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service) => _didUpdateAssociatedServiceType.OnNext((accessory, service)); + /// + public override void DidUpdateFirmwareVersion(global::HomeKit.HMAccessory accessory, string firmwareVersion) => _didUpdateFirmwareVersion.OnNext((accessory, firmwareVersion)); + /// + public override void DidUpdateName(global::HomeKit.HMAccessory accessory) => _didUpdateName.OnNext(accessory); + /// + public override void DidUpdateNameForService(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service) => _didUpdateNameForService.OnNext((accessory, service)); + /// + public override void DidUpdateReachability(global::HomeKit.HMAccessory accessory) => _didUpdateReachability.OnNext(accessory); + /// + public override void DidUpdateServices(global::HomeKit.HMAccessory accessory) => _didUpdateServices.OnNext(accessory); + /// + public override void DidUpdateValueForCharacteristic(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service, global::HomeKit.HMCharacteristic characteristic) => _didUpdateValueForCharacteristic.OnNext((accessory, service, characteristic)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class HMCameraSnapshotControlDelegateRx : global::HomeKit.HMCameraSnapshotControlDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMCameraSnapshotControl cameraSnapshotControl, global::HomeKit.HMCameraSnapshot snapshot, global::Foundation.NSError error)> _didTakeSnapshot = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMCameraSnapshotControl cameraSnapshotControl, global::HomeKit.HMCameraSnapshot snapshot, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateMostRecentSnapshot = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMCameraSnapshotControl cameraSnapshotControl, global::HomeKit.HMCameraSnapshot snapshot, global::Foundation.NSError error)> DidTakeSnapshotObs => _didTakeSnapshot; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateMostRecentSnapshotObs => _didUpdateMostRecentSnapshot; + /// + public override void DidTakeSnapshot(global::HomeKit.HMCameraSnapshotControl cameraSnapshotControl, global::HomeKit.HMCameraSnapshot snapshot, global::Foundation.NSError error) => _didTakeSnapshot.OnNext((cameraSnapshotControl, snapshot, error)); + /// + public override void DidUpdateMostRecentSnapshot(global::HomeKit.HMCameraSnapshotControl cameraSnapshotControl) => _didUpdateMostRecentSnapshot.OnNext(cameraSnapshotControl); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class HMCameraStreamControlDelegateRx : global::HomeKit.HMCameraStreamControlDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didStartStream = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMCameraStreamControl cameraStreamControl, global::Foundation.NSError error)> _didStopStream = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMCameraStreamControl cameraStreamControl, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidStartStreamObs => _didStartStream; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMCameraStreamControl cameraStreamControl, global::Foundation.NSError error)> DidStopStreamObs => _didStopStream; + /// + public override void DidStartStream(global::HomeKit.HMCameraStreamControl cameraStreamControl) => _didStartStream.OnNext(cameraStreamControl); + /// + public override void DidStopStream(global::HomeKit.HMCameraStreamControl cameraStreamControl, global::Foundation.NSError error) => _didStopStream.OnNext((cameraStreamControl, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class HMHomeDelegateRx : global::HomeKit.HMHomeDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)> _didAddAccessory = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> _didAddActionSet = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)> _didAddRoom = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone)> _didAddRoomToZone = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group)> _didAddService = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)> _didAddServiceGroup = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> _didAddTrigger = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMUser user)> _didAddUser = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMUser user)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)> _didAddZone = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::Foundation.NSError error, global::HomeKit.HMAccessory accessory)> _didEncounterError = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::Foundation.NSError error, global::HomeKit.HMAccessory accessory)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)> _didRemoveAccessory = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> _didRemoveActionSet = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)> _didRemoveRoom = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone)> _didRemoveRoomFromZone = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group)> _didRemoveService = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)> _didRemoveServiceGroup = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> _didRemoveTrigger = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMUser user)> _didRemoveUser = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMUser user)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)> _didRemoveZone = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)> _didUnblockAccessory = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateAccessControlForCurrentUser = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> _didUpdateActionsForActionSet = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMHomeHubState homeHubState)> _didUpdateHomeHubState = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMHomeHubState homeHubState)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> _didUpdateNameForActionSet = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateNameForHome = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)> _didUpdateNameForRoom = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)> _didUpdateNameForServiceGroup = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> _didUpdateNameForTrigger = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)> _didUpdateNameForZone = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMAccessory accessory)> _didUpdateRoom = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMAccessory accessory)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateSupportedFeatures = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> _didUpdateTrigger = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)> DidAddAccessoryObs => _didAddAccessory; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> DidAddActionSetObs => _didAddActionSet; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)> DidAddRoomObs => _didAddRoom; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone)> DidAddRoomToZoneObs => _didAddRoomToZone; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group)> DidAddServiceObs => _didAddService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)> DidAddServiceGroupObs => _didAddServiceGroup; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> DidAddTriggerObs => _didAddTrigger; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMUser user)> DidAddUserObs => _didAddUser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)> DidAddZoneObs => _didAddZone; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::Foundation.NSError error, global::HomeKit.HMAccessory accessory)> DidEncounterErrorObs => _didEncounterError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)> DidRemoveAccessoryObs => _didRemoveAccessory; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> DidRemoveActionSetObs => _didRemoveActionSet; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)> DidRemoveRoomObs => _didRemoveRoom; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone)> DidRemoveRoomFromZoneObs => _didRemoveRoomFromZone; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group)> DidRemoveServiceObs => _didRemoveService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)> DidRemoveServiceGroupObs => _didRemoveServiceGroup; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> DidRemoveTriggerObs => _didRemoveTrigger; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMUser user)> DidRemoveUserObs => _didRemoveUser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)> DidRemoveZoneObs => _didRemoveZone; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)> DidUnblockAccessoryObs => _didUnblockAccessory; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateAccessControlForCurrentUserObs => _didUpdateAccessControlForCurrentUser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> DidUpdateActionsForActionSetObs => _didUpdateActionsForActionSet; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMHomeHubState homeHubState)> DidUpdateHomeHubStateObs => _didUpdateHomeHubState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> DidUpdateNameForActionSetObs => _didUpdateNameForActionSet; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateNameForHomeObs => _didUpdateNameForHome; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)> DidUpdateNameForRoomObs => _didUpdateNameForRoom; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)> DidUpdateNameForServiceGroupObs => _didUpdateNameForServiceGroup; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> DidUpdateNameForTriggerObs => _didUpdateNameForTrigger; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)> DidUpdateNameForZoneObs => _didUpdateNameForZone; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMAccessory accessory)> DidUpdateRoomObs => _didUpdateRoom; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateSupportedFeaturesObs => _didUpdateSupportedFeatures; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> DidUpdateTriggerObs => _didUpdateTrigger; + /// + public override void DidAddAccessory(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory) => _didAddAccessory.OnNext((home, accessory)); + /// + public override void DidAddActionSet(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet) => _didAddActionSet.OnNext((home, actionSet)); + /// + public override void DidAddRoom(global::HomeKit.HMHome home, global::HomeKit.HMRoom room) => _didAddRoom.OnNext((home, room)); + /// + public override void DidAddRoomToZone(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone) => _didAddRoomToZone.OnNext((home, room, zone)); + /// + public override void DidAddService(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group) => _didAddService.OnNext((home, service, group)); + /// + public override void DidAddServiceGroup(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group) => _didAddServiceGroup.OnNext((home, group)); + /// + public override void DidAddTrigger(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger) => _didAddTrigger.OnNext((home, trigger)); + /// + public override void DidAddUser(global::HomeKit.HMHome home, global::HomeKit.HMUser user) => _didAddUser.OnNext((home, user)); + /// + public override void DidAddZone(global::HomeKit.HMHome home, global::HomeKit.HMZone zone) => _didAddZone.OnNext((home, zone)); + /// + public override void DidEncounterError(global::HomeKit.HMHome home, global::Foundation.NSError error, global::HomeKit.HMAccessory accessory) => _didEncounterError.OnNext((home, error, accessory)); + /// + public override void DidRemoveAccessory(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory) => _didRemoveAccessory.OnNext((home, accessory)); + /// + public override void DidRemoveActionSet(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet) => _didRemoveActionSet.OnNext((home, actionSet)); + /// + public override void DidRemoveRoom(global::HomeKit.HMHome home, global::HomeKit.HMRoom room) => _didRemoveRoom.OnNext((home, room)); + /// + public override void DidRemoveRoomFromZone(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone) => _didRemoveRoomFromZone.OnNext((home, room, zone)); + /// + public override void DidRemoveService(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group) => _didRemoveService.OnNext((home, service, group)); + /// + public override void DidRemoveServiceGroup(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group) => _didRemoveServiceGroup.OnNext((home, group)); + /// + public override void DidRemoveTrigger(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger) => _didRemoveTrigger.OnNext((home, trigger)); + /// + public override void DidRemoveUser(global::HomeKit.HMHome home, global::HomeKit.HMUser user) => _didRemoveUser.OnNext((home, user)); + /// + public override void DidRemoveZone(global::HomeKit.HMHome home, global::HomeKit.HMZone zone) => _didRemoveZone.OnNext((home, zone)); + /// + public override void DidUnblockAccessory(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory) => _didUnblockAccessory.OnNext((home, accessory)); + /// + public override void DidUpdateAccessControlForCurrentUser(global::HomeKit.HMHome home) => _didUpdateAccessControlForCurrentUser.OnNext(home); + /// + public override void DidUpdateActionsForActionSet(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet) => _didUpdateActionsForActionSet.OnNext((home, actionSet)); + /// + public override void DidUpdateHomeHubState(global::HomeKit.HMHome home, global::HomeKit.HMHomeHubState homeHubState) => _didUpdateHomeHubState.OnNext((home, homeHubState)); + /// + public override void DidUpdateNameForActionSet(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet) => _didUpdateNameForActionSet.OnNext((home, actionSet)); + /// + public override void DidUpdateNameForHome(global::HomeKit.HMHome home) => _didUpdateNameForHome.OnNext(home); + /// + public override void DidUpdateNameForRoom(global::HomeKit.HMHome home, global::HomeKit.HMRoom room) => _didUpdateNameForRoom.OnNext((home, room)); + /// + public override void DidUpdateNameForServiceGroup(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group) => _didUpdateNameForServiceGroup.OnNext((home, group)); + /// + public override void DidUpdateNameForTrigger(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger) => _didUpdateNameForTrigger.OnNext((home, trigger)); + /// + public override void DidUpdateNameForZone(global::HomeKit.HMHome home, global::HomeKit.HMZone zone) => _didUpdateNameForZone.OnNext((home, zone)); + /// + public override void DidUpdateRoom(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMAccessory accessory) => _didUpdateRoom.OnNext((home, room, accessory)); + /// + public override void DidUpdateSupportedFeatures(global::HomeKit.HMHome home) => _didUpdateSupportedFeatures.OnNext(home); + /// + public override void DidUpdateTrigger(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger) => _didUpdateTrigger.OnNext((home, trigger)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class HMHomeManagerDelegateRx : global::HomeKit.HMHomeManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home)> _didAddHome = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMAddAccessoryRequest request)> _didReceiveAddAccessoryRequest = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMAddAccessoryRequest request)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home)> _didRemoveHome = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHomeManagerAuthorizationStatus status)> _didUpdateAuthorizationStatus = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHomeManagerAuthorizationStatus status)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateHomes = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdatePrimaryHome = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home)> DidAddHomeObs => _didAddHome; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMAddAccessoryRequest request)> DidReceiveAddAccessoryRequestObs => _didReceiveAddAccessoryRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home)> DidRemoveHomeObs => _didRemoveHome; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHomeManagerAuthorizationStatus status)> DidUpdateAuthorizationStatusObs => _didUpdateAuthorizationStatus; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateHomesObs => _didUpdateHomes; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdatePrimaryHomeObs => _didUpdatePrimaryHome; + /// + public override void DidAddHome(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home) => _didAddHome.OnNext((manager, home)); + /// + public override void DidReceiveAddAccessoryRequest(global::HomeKit.HMHomeManager manager, global::HomeKit.HMAddAccessoryRequest request) => _didReceiveAddAccessoryRequest.OnNext((manager, request)); + /// + public override void DidRemoveHome(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home) => _didRemoveHome.OnNext((manager, home)); + /// + public override void DidUpdateAuthorizationStatus(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHomeManagerAuthorizationStatus status) => _didUpdateAuthorizationStatus.OnNext((manager, status)); + /// + public override void DidUpdateHomes(global::HomeKit.HMHomeManager manager) => _didUpdateHomes.OnNext(manager); + /// + public override void DidUpdatePrimaryHome(global::HomeKit.HMHomeManager manager) => _didUpdatePrimaryHome.OnNext(manager); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class HMNetworkConfigurationProfileDelegateRx : global::HomeKit.HMNetworkConfigurationProfileDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateNetworkAccessMode = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateNetworkAccessModeObs => _didUpdateNetworkAccessMode; + /// + public override void DidUpdateNetworkAccessMode(global::HomeKit.HMNetworkConfigurationProfile profile) => _didUpdateNetworkAccessMode.OnNext(profile); + } +} + +namespace iAd +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class ADBannerViewDelegateRx : global::iAd.ADBannerViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _actionFinished = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _adLoaded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::iAd.ADBannerView banner, global::Foundation.NSError error)> _failedToReceiveAd = new Pharmacist.Common.SingleAwaitSubject<(global::iAd.ADBannerView banner, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willLoad = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ActionFinishedObs => _actionFinished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable AdLoadedObs => _adLoaded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::iAd.ADBannerView banner, global::Foundation.NSError error)> FailedToReceiveAdObs => _failedToReceiveAd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillLoadObs => _willLoad; + /// + public override void ActionFinished(global::iAd.ADBannerView banner) => _actionFinished.OnNext(banner); + /// + public override void AdLoaded(global::iAd.ADBannerView banner) => _adLoaded.OnNext(banner); + /// + public override void FailedToReceiveAd(global::iAd.ADBannerView banner, global::Foundation.NSError error) => _failedToReceiveAd.OnNext((banner, error)); + /// + public override void WillLoad(global::iAd.ADBannerView bannerView) => _willLoad.OnNext(bannerView); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class ADInterstitialAdDelegateRx : global::iAd.ADInterstitialAdDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _actionFinished = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _adLoaded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _adUnloaded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::iAd.ADInterstitialAd interstitialAd, global::Foundation.NSError error)> _failedToReceiveAd = new Pharmacist.Common.SingleAwaitSubject<(global::iAd.ADInterstitialAd interstitialAd, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willLoad = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ActionFinishedObs => _actionFinished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable AdLoadedObs => _adLoaded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable AdUnloadedObs => _adUnloaded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::iAd.ADInterstitialAd interstitialAd, global::Foundation.NSError error)> FailedToReceiveAdObs => _failedToReceiveAd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillLoadObs => _willLoad; + /// + public override void ActionFinished(global::iAd.ADInterstitialAd interstitialAd) => _actionFinished.OnNext(interstitialAd); + /// + public override void AdLoaded(global::iAd.ADInterstitialAd interstitialAd) => _adLoaded.OnNext(interstitialAd); + /// + public override void AdUnloaded(global::iAd.ADInterstitialAd interstitialAd) => _adUnloaded.OnNext(interstitialAd); + /// + public override void FailedToReceiveAd(global::iAd.ADInterstitialAd interstitialAd, global::Foundation.NSError error) => _failedToReceiveAd.OnNext((interstitialAd, error)); + /// + public override void WillLoad(global::iAd.ADInterstitialAd interstitialAd) => _willLoad.OnNext(interstitialAd); + } +} + +namespace IntentsUI +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class INUIAddVoiceShortcutButtonDelegateRx : global::IntentsUI.INUIAddVoiceShortcutButtonDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::IntentsUI.INUIAddVoiceShortcutViewController addVoiceShortcutViewController, global::IntentsUI.INUIAddVoiceShortcutButton addVoiceShortcutButton)> _presentAddVoiceShortcut = new Pharmacist.Common.SingleAwaitSubject<(global::IntentsUI.INUIAddVoiceShortcutViewController addVoiceShortcutViewController, global::IntentsUI.INUIAddVoiceShortcutButton addVoiceShortcutButton)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::IntentsUI.INUIEditVoiceShortcutViewController editVoiceShortcutViewController, global::IntentsUI.INUIAddVoiceShortcutButton addVoiceShortcutButton)> _presentEditVoiceShortcut = new Pharmacist.Common.SingleAwaitSubject<(global::IntentsUI.INUIEditVoiceShortcutViewController editVoiceShortcutViewController, global::IntentsUI.INUIAddVoiceShortcutButton addVoiceShortcutButton)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::IntentsUI.INUIAddVoiceShortcutViewController addVoiceShortcutViewController, global::IntentsUI.INUIAddVoiceShortcutButton addVoiceShortcutButton)> PresentAddVoiceShortcutObs => _presentAddVoiceShortcut; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::IntentsUI.INUIEditVoiceShortcutViewController editVoiceShortcutViewController, global::IntentsUI.INUIAddVoiceShortcutButton addVoiceShortcutButton)> PresentEditVoiceShortcutObs => _presentEditVoiceShortcut; + /// + public override void PresentAddVoiceShortcut(global::IntentsUI.INUIAddVoiceShortcutViewController addVoiceShortcutViewController, global::IntentsUI.INUIAddVoiceShortcutButton addVoiceShortcutButton) => _presentAddVoiceShortcut.OnNext((addVoiceShortcutViewController, addVoiceShortcutButton)); + /// + public override void PresentEditVoiceShortcut(global::IntentsUI.INUIEditVoiceShortcutViewController editVoiceShortcutViewController, global::IntentsUI.INUIAddVoiceShortcutButton addVoiceShortcutButton) => _presentEditVoiceShortcut.OnNext((editVoiceShortcutViewController, addVoiceShortcutButton)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class INUIAddVoiceShortcutViewControllerDelegateRx : global::IntentsUI.INUIAddVoiceShortcutViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didCancel = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::IntentsUI.INUIAddVoiceShortcutViewController controller, global::Intents.INVoiceShortcut voiceShortcut, global::Foundation.NSError error)> _didFinish = new Pharmacist.Common.SingleAwaitSubject<(global::IntentsUI.INUIAddVoiceShortcutViewController controller, global::Intents.INVoiceShortcut voiceShortcut, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidCancelObs => _didCancel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::IntentsUI.INUIAddVoiceShortcutViewController controller, global::Intents.INVoiceShortcut voiceShortcut, global::Foundation.NSError error)> DidFinishObs => _didFinish; + /// + public override void DidCancel(global::IntentsUI.INUIAddVoiceShortcutViewController controller) => _didCancel.OnNext(controller); + /// + public override void DidFinish(global::IntentsUI.INUIAddVoiceShortcutViewController controller, global::Intents.INVoiceShortcut voiceShortcut, global::Foundation.NSError error) => _didFinish.OnNext((controller, voiceShortcut, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class INUIEditVoiceShortcutViewControllerDelegateRx : global::IntentsUI.INUIEditVoiceShortcutViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didCancel = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::IntentsUI.INUIEditVoiceShortcutViewController controller, global::Foundation.NSUuid deletedVoiceShortcutIdentifier)> _didDelete = new Pharmacist.Common.SingleAwaitSubject<(global::IntentsUI.INUIEditVoiceShortcutViewController controller, global::Foundation.NSUuid deletedVoiceShortcutIdentifier)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::IntentsUI.INUIEditVoiceShortcutViewController controller, global::Intents.INVoiceShortcut voiceShortcut, global::Foundation.NSError error)> _didUpdate = new Pharmacist.Common.SingleAwaitSubject<(global::IntentsUI.INUIEditVoiceShortcutViewController controller, global::Intents.INVoiceShortcut voiceShortcut, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidCancelObs => _didCancel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::IntentsUI.INUIEditVoiceShortcutViewController controller, global::Foundation.NSUuid deletedVoiceShortcutIdentifier)> DidDeleteObs => _didDelete; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::IntentsUI.INUIEditVoiceShortcutViewController controller, global::Intents.INVoiceShortcut voiceShortcut, global::Foundation.NSError error)> DidUpdateObs => _didUpdate; + /// + public override void DidCancel(global::IntentsUI.INUIEditVoiceShortcutViewController controller) => _didCancel.OnNext(controller); + /// + public override void DidDelete(global::IntentsUI.INUIEditVoiceShortcutViewController controller, global::Foundation.NSUuid deletedVoiceShortcutIdentifier) => _didDelete.OnNext((controller, deletedVoiceShortcutIdentifier)); + /// + public override void DidUpdate(global::IntentsUI.INUIEditVoiceShortcutViewController controller, global::Intents.INVoiceShortcut voiceShortcut, global::Foundation.NSError error) => _didUpdate.OnNext((controller, voiceShortcut, error)); + } +} + +namespace MapKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class MKLocalSearchCompleterDelegateRx : global::MapKit.MKLocalSearchCompleterDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKLocalSearchCompleter completer, global::Foundation.NSError error)> _didFail = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKLocalSearchCompleter completer, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateResults = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKLocalSearchCompleter completer, global::Foundation.NSError error)> DidFailObs => _didFail; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateResultsObs => _didUpdateResults; + /// + public override void DidFail(global::MapKit.MKLocalSearchCompleter completer, global::Foundation.NSError error) => _didFail.OnNext((completer, error)); + /// + public override void DidUpdateResults(global::MapKit.MKLocalSearchCompleter completer) => _didUpdateResults.OnNext(completer); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class MKMapViewDelegateRx : global::MapKit.MKMapViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view, global::UIKit.UIControl control)> _calloutAccessoryControlTapped = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view, global::UIKit.UIControl control)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView annotationView, global::MapKit.MKAnnotationViewDragState newState, global::MapKit.MKAnnotationViewDragState oldState)> _changedDragState = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView annotationView, global::MapKit.MKAnnotationViewDragState newState, global::MapKit.MKAnnotationViewDragState oldState)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView[] views)> _didAddAnnotationViews = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView[] views)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKOverlayRenderer[] renderers)> _didAddOverlayRenderers = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKOverlayRenderer[] renderers)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKOverlayView overlayViews)> _didAddOverlayViews = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKOverlayView overlayViews)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKUserTrackingMode mode, bool animated)> _didChangeUserTrackingMode = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKUserTrackingMode mode, bool animated)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeVisibleRegion = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view)> _didDeselectAnnotationView = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::Foundation.NSError error)> _didFailToLocateUser = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, bool fullyRendered)> _didFinishRenderingMap = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, bool fullyRendered)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view)> _didSelectAnnotationView = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didStopLocatingUser = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKUserLocation userLocation)> _didUpdateUserLocation = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKUserLocation userLocation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::Foundation.NSError error)> _loadingMapFailed = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _mapLoaded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, bool animated)> _regionChanged = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, bool animated)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, bool animated)> _regionWillChange = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, bool animated)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStartLoadingMap = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStartLocatingUser = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStartRenderingMap = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view, global::UIKit.UIControl control)> CalloutAccessoryControlTappedObs => _calloutAccessoryControlTapped; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView annotationView, global::MapKit.MKAnnotationViewDragState newState, global::MapKit.MKAnnotationViewDragState oldState)> ChangedDragStateObs => _changedDragState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView[] views)> DidAddAnnotationViewsObs => _didAddAnnotationViews; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKOverlayRenderer[] renderers)> DidAddOverlayRenderersObs => _didAddOverlayRenderers; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKOverlayView overlayViews)> DidAddOverlayViewsObs => _didAddOverlayViews; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKUserTrackingMode mode, bool animated)> DidChangeUserTrackingModeObs => _didChangeUserTrackingMode; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeVisibleRegionObs => _didChangeVisibleRegion; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view)> DidDeselectAnnotationViewObs => _didDeselectAnnotationView; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::Foundation.NSError error)> DidFailToLocateUserObs => _didFailToLocateUser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, bool fullyRendered)> DidFinishRenderingMapObs => _didFinishRenderingMap; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view)> DidSelectAnnotationViewObs => _didSelectAnnotationView; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidStopLocatingUserObs => _didStopLocatingUser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKUserLocation userLocation)> DidUpdateUserLocationObs => _didUpdateUserLocation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::Foundation.NSError error)> LoadingMapFailedObs => _loadingMapFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable MapLoadedObs => _mapLoaded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, bool animated)> RegionChangedObs => _regionChanged; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, bool animated)> RegionWillChangeObs => _regionWillChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStartLoadingMapObs => _willStartLoadingMap; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStartLocatingUserObs => _willStartLocatingUser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStartRenderingMapObs => _willStartRenderingMap; + /// + public override void CalloutAccessoryControlTapped(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view, global::UIKit.UIControl control) => _calloutAccessoryControlTapped.OnNext((mapView, view, control)); + /// + public override void ChangedDragState(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView annotationView, global::MapKit.MKAnnotationViewDragState newState, global::MapKit.MKAnnotationViewDragState oldState) => _changedDragState.OnNext((mapView, annotationView, newState, oldState)); + /// + public override void DidAddAnnotationViews(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView[] views) => _didAddAnnotationViews.OnNext((mapView, views)); + /// + public override void DidAddOverlayRenderers(global::MapKit.MKMapView mapView, global::MapKit.MKOverlayRenderer[] renderers) => _didAddOverlayRenderers.OnNext((mapView, renderers)); + /// + public override void DidAddOverlayViews(global::MapKit.MKMapView mapView, global::MapKit.MKOverlayView overlayViews) => _didAddOverlayViews.OnNext((mapView, overlayViews)); + /// + public override void DidChangeUserTrackingMode(global::MapKit.MKMapView mapView, global::MapKit.MKUserTrackingMode mode, bool animated) => _didChangeUserTrackingMode.OnNext((mapView, mode, animated)); + /// + public override void DidChangeVisibleRegion(global::MapKit.MKMapView mapView) => _didChangeVisibleRegion.OnNext(mapView); + /// + public override void DidDeselectAnnotationView(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view) => _didDeselectAnnotationView.OnNext((mapView, view)); + /// + public override void DidFailToLocateUser(global::MapKit.MKMapView mapView, global::Foundation.NSError error) => _didFailToLocateUser.OnNext((mapView, error)); + /// + public override void DidFinishRenderingMap(global::MapKit.MKMapView mapView, bool fullyRendered) => _didFinishRenderingMap.OnNext((mapView, fullyRendered)); + /// + public override void DidSelectAnnotationView(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view) => _didSelectAnnotationView.OnNext((mapView, view)); + /// + public override void DidStopLocatingUser(global::MapKit.MKMapView mapView) => _didStopLocatingUser.OnNext(mapView); + /// + public override void DidUpdateUserLocation(global::MapKit.MKMapView mapView, global::MapKit.MKUserLocation userLocation) => _didUpdateUserLocation.OnNext((mapView, userLocation)); + /// + public override void LoadingMapFailed(global::MapKit.MKMapView mapView, global::Foundation.NSError error) => _loadingMapFailed.OnNext((mapView, error)); + /// + public override void MapLoaded(global::MapKit.MKMapView mapView) => _mapLoaded.OnNext(mapView); + /// + public override void RegionChanged(global::MapKit.MKMapView mapView, bool animated) => _regionChanged.OnNext((mapView, animated)); + /// + public override void RegionWillChange(global::MapKit.MKMapView mapView, bool animated) => _regionWillChange.OnNext((mapView, animated)); + /// + public override void WillStartLoadingMap(global::MapKit.MKMapView mapView) => _willStartLoadingMap.OnNext(mapView); + /// + public override void WillStartLocatingUser(global::MapKit.MKMapView mapView) => _willStartLocatingUser.OnNext(mapView); + /// + public override void WillStartRenderingMap(global::MapKit.MKMapView mapView) => _willStartRenderingMap.OnNext(mapView); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class MKReverseGeocoderDelegateRx : global::MapKit.MKReverseGeocoderDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKReverseGeocoder geocoder, global::Foundation.NSError error)> _failedWithError = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKReverseGeocoder geocoder, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKReverseGeocoder geocoder, global::MapKit.MKPlacemark placemark)> _foundWithPlacemark = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKReverseGeocoder geocoder, global::MapKit.MKPlacemark placemark)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKReverseGeocoder geocoder, global::Foundation.NSError error)> FailedWithErrorObs => _failedWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKReverseGeocoder geocoder, global::MapKit.MKPlacemark placemark)> FoundWithPlacemarkObs => _foundWithPlacemark; + /// + public override void FailedWithError(global::MapKit.MKReverseGeocoder geocoder, global::Foundation.NSError error) => _failedWithError.OnNext((geocoder, error)); + /// + public override void FoundWithPlacemark(global::MapKit.MKReverseGeocoder geocoder, global::MapKit.MKPlacemark placemark) => _foundWithPlacemark.OnNext((geocoder, placemark)); + } +} + +namespace MediaPlayer +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class MPMediaPickerControllerDelegateRx : global::MediaPlayer.MPMediaPickerControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MediaPlayer.MPMediaPickerController sender, global::MediaPlayer.MPMediaItemCollection mediaItemCollection)> _mediaItemsPicked = new Pharmacist.Common.SingleAwaitSubject<(global::MediaPlayer.MPMediaPickerController sender, global::MediaPlayer.MPMediaItemCollection mediaItemCollection)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _mediaPickerDidCancel = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MediaPlayer.MPMediaPickerController sender, global::MediaPlayer.MPMediaItemCollection mediaItemCollection)> MediaItemsPickedObs => _mediaItemsPicked; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable MediaPickerDidCancelObs => _mediaPickerDidCancel; + /// + public override void MediaItemsPicked(global::MediaPlayer.MPMediaPickerController sender, global::MediaPlayer.MPMediaItemCollection mediaItemCollection) => _mediaItemsPicked.OnNext((sender, mediaItemCollection)); + /// + public override void MediaPickerDidCancel(global::MediaPlayer.MPMediaPickerController sender) => _mediaPickerDidCancel.OnNext(sender); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class MPPlayableContentDelegateRx : global::MediaPlayer.MPPlayableContentDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MediaPlayer.MPPlayableContentManager contentManager, global::MediaPlayer.MPPlayableContentManagerContext context)> _contextUpdated = new Pharmacist.Common.SingleAwaitSubject<(global::MediaPlayer.MPPlayableContentManager contentManager, global::MediaPlayer.MPPlayableContentManagerContext context)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MediaPlayer.MPPlayableContentManager contentManager, global::MediaPlayer.MPContentItem[] contentItems, global::System.Action completionHandler)> _initializePlaybackQueue = new Pharmacist.Common.SingleAwaitSubject<(global::MediaPlayer.MPPlayableContentManager contentManager, global::MediaPlayer.MPContentItem[] contentItems, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MediaPlayer.MPPlayableContentManager contentManager, global::Foundation.NSIndexPath indexPath, global::System.Action completionHandler)> _initiatePlaybackOfContentItem = new Pharmacist.Common.SingleAwaitSubject<(global::MediaPlayer.MPPlayableContentManager contentManager, global::Foundation.NSIndexPath indexPath, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MediaPlayer.MPPlayableContentManager contentManager, global::Foundation.NSIndexPath indexPath, global::System.Action completionHandler)> _playableContentManager = new Pharmacist.Common.SingleAwaitSubject<(global::MediaPlayer.MPPlayableContentManager contentManager, global::Foundation.NSIndexPath indexPath, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MediaPlayer.MPPlayableContentManager contentManager, global::MediaPlayer.MPPlayableContentManagerContext context)> ContextUpdatedObs => _contextUpdated; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MediaPlayer.MPPlayableContentManager contentManager, global::MediaPlayer.MPContentItem[] contentItems, global::System.Action completionHandler)> InitializePlaybackQueueObs => _initializePlaybackQueue; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MediaPlayer.MPPlayableContentManager contentManager, global::Foundation.NSIndexPath indexPath, global::System.Action completionHandler)> InitiatePlaybackOfContentItemObs => _initiatePlaybackOfContentItem; + /// + /// Gets an observable which signals when the method is invoked. + /// + [global::System.ObsoleteAttribute("Use 'InitiatePlaybackOfContentItem' instead.", false)] + public global::System.IObservable<(global::MediaPlayer.MPPlayableContentManager contentManager, global::Foundation.NSIndexPath indexPath, global::System.Action completionHandler)> PlayableContentManagerObs => _playableContentManager; + /// + public override void ContextUpdated(global::MediaPlayer.MPPlayableContentManager contentManager, global::MediaPlayer.MPPlayableContentManagerContext context) => _contextUpdated.OnNext((contentManager, context)); + /// + public override void InitializePlaybackQueue(global::MediaPlayer.MPPlayableContentManager contentManager, global::MediaPlayer.MPContentItem[] contentItems, global::System.Action completionHandler) => _initializePlaybackQueue.OnNext((contentManager, contentItems, completionHandler)); + /// + public override void InitiatePlaybackOfContentItem(global::MediaPlayer.MPPlayableContentManager contentManager, global::Foundation.NSIndexPath indexPath, global::System.Action completionHandler) => _initiatePlaybackOfContentItem.OnNext((contentManager, indexPath, completionHandler)); + /// + [global::System.ObsoleteAttribute("Use 'InitiatePlaybackOfContentItem' instead.", false)] + public override void PlayableContentManager(global::MediaPlayer.MPPlayableContentManager contentManager, global::Foundation.NSIndexPath indexPath, global::System.Action completionHandler) => _playableContentManager.OnNext((contentManager, indexPath, completionHandler)); + } +} + +namespace MessageUI +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class MFMailComposeViewControllerDelegateRx : global::MessageUI.MFMailComposeViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MessageUI.MFMailComposeViewController controller, global::MessageUI.MFMailComposeResult result, global::Foundation.NSError error)> _finished = new Pharmacist.Common.SingleAwaitSubject<(global::MessageUI.MFMailComposeViewController controller, global::MessageUI.MFMailComposeResult result, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MessageUI.MFMailComposeViewController controller, global::MessageUI.MFMailComposeResult result, global::Foundation.NSError error)> FinishedObs => _finished; + /// + public override void Finished(global::MessageUI.MFMailComposeViewController controller, global::MessageUI.MFMailComposeResult result, global::Foundation.NSError error) => _finished.OnNext((controller, result, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class MFMessageComposeViewControllerDelegateRx : global::MessageUI.MFMessageComposeViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MessageUI.MFMessageComposeViewController controller, global::MessageUI.MessageComposeResult result)> _finished = new Pharmacist.Common.SingleAwaitSubject<(global::MessageUI.MFMessageComposeViewController controller, global::MessageUI.MessageComposeResult result)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MessageUI.MFMessageComposeViewController controller, global::MessageUI.MessageComposeResult result)> FinishedObs => _finished; + /// + public override void Finished(global::MessageUI.MFMessageComposeViewController controller, global::MessageUI.MessageComposeResult result) => _finished.OnNext((controller, result)); + } +} + +namespace MetalKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class MTKViewDelegateRx : global::MetalKit.MTKViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _draw = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MetalKit.MTKView view, global::CoreGraphics.CGSize size)> _drawableSizeWillChange = new Pharmacist.Common.SingleAwaitSubject<(global::MetalKit.MTKView view, global::CoreGraphics.CGSize size)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DrawObs => _draw; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MetalKit.MTKView view, global::CoreGraphics.CGSize size)> DrawableSizeWillChangeObs => _drawableSizeWillChange; + /// + public override void Draw(global::MetalKit.MTKView view) => _draw.OnNext(view); + /// + public override void DrawableSizeWillChange(global::MetalKit.MTKView view, global::CoreGraphics.CGSize size) => _drawableSizeWillChange.OnNext((view, size)); + } +} + +namespace MultipeerConnectivity +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class MCAdvertiserAssistantDelegateRx : global::MultipeerConnectivity.MCAdvertiserAssistantDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didDismissInvitation = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willPresentInvitation = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDismissInvitationObs => _didDismissInvitation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillPresentInvitationObs => _willPresentInvitation; + /// + public override void DidDismissInvitation(global::MultipeerConnectivity.MCAdvertiserAssistant advertiserAssistant) => _didDismissInvitation.OnNext(advertiserAssistant); + /// + public override void WillPresentInvitation(global::MultipeerConnectivity.MCAdvertiserAssistant advertiserAssistant) => _willPresentInvitation.OnNext(advertiserAssistant); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class MCBrowserViewControllerDelegateRx : global::MultipeerConnectivity.MCBrowserViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didFinish = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _wasCancelled = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishObs => _didFinish; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WasCancelledObs => _wasCancelled; + /// + public override void DidFinish(global::MultipeerConnectivity.MCBrowserViewController browserViewController) => _didFinish.OnNext(browserViewController); + /// + public override void WasCancelled(global::MultipeerConnectivity.MCBrowserViewController browserViewController) => _wasCancelled.OnNext(browserViewController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class MCNearbyServiceAdvertiserDelegateRx : global::MultipeerConnectivity.MCNearbyServiceAdvertiserDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::Foundation.NSError error)> _didNotStartAdvertisingPeer = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSData context, global::MultipeerConnectivity.MCNearbyServiceAdvertiserInvitationHandler invitationHandler)> _didReceiveInvitationFromPeer = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSData context, global::MultipeerConnectivity.MCNearbyServiceAdvertiserInvitationHandler invitationHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::Foundation.NSError error)> DidNotStartAdvertisingPeerObs => _didNotStartAdvertisingPeer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSData context, global::MultipeerConnectivity.MCNearbyServiceAdvertiserInvitationHandler invitationHandler)> DidReceiveInvitationFromPeerObs => _didReceiveInvitationFromPeer; + /// + public override void DidNotStartAdvertisingPeer(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::Foundation.NSError error) => _didNotStartAdvertisingPeer.OnNext((advertiser, error)); + /// + public override void DidReceiveInvitationFromPeer(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSData context, global::MultipeerConnectivity.MCNearbyServiceAdvertiserInvitationHandler invitationHandler) => _didReceiveInvitationFromPeer.OnNext((advertiser, peerID, context, invitationHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class MCNearbyServiceBrowserDelegateRx : global::MultipeerConnectivity.MCNearbyServiceBrowserDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::Foundation.NSError error)> _didNotStartBrowsingForPeers = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSDictionary info)> _foundPeer = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSDictionary info)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID)> _lostPeer = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::Foundation.NSError error)> DidNotStartBrowsingForPeersObs => _didNotStartBrowsingForPeers; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSDictionary info)> FoundPeerObs => _foundPeer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID)> LostPeerObs => _lostPeer; + /// + public override void DidNotStartBrowsingForPeers(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::Foundation.NSError error) => _didNotStartBrowsingForPeers.OnNext((browser, error)); + /// + public override void FoundPeer(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSDictionary info) => _foundPeer.OnNext((browser, peerID, info)); + /// + public override void LostPeer(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID) => _lostPeer.OnNext((browser, peerID)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class MCSessionDelegateRx : global::MultipeerConnectivity.MCSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, global::MultipeerConnectivity.MCPeerID peerID, global::MultipeerConnectivity.MCSessionState state)> _didChangeState = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, global::MultipeerConnectivity.MCPeerID peerID, global::MultipeerConnectivity.MCSessionState state)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSUrl localUrl, global::Foundation.NSError error)> _didFinishReceivingResource = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSUrl localUrl, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, global::Foundation.NSData data, global::MultipeerConnectivity.MCPeerID peerID)> _didReceiveData = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, global::Foundation.NSData data, global::MultipeerConnectivity.MCPeerID peerID)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, global::Foundation.NSInputStream stream, string streamName, global::MultipeerConnectivity.MCPeerID peerID)> _didReceiveStream = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, global::Foundation.NSInputStream stream, string streamName, global::MultipeerConnectivity.MCPeerID peerID)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSProgress progress)> _didStartReceivingResource = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSProgress progress)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCSession session, global::MultipeerConnectivity.MCPeerID peerID, global::MultipeerConnectivity.MCSessionState state)> DidChangeStateObs => _didChangeState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSUrl localUrl, global::Foundation.NSError error)> DidFinishReceivingResourceObs => _didFinishReceivingResource; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCSession session, global::Foundation.NSData data, global::MultipeerConnectivity.MCPeerID peerID)> DidReceiveDataObs => _didReceiveData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCSession session, global::Foundation.NSInputStream stream, string streamName, global::MultipeerConnectivity.MCPeerID peerID)> DidReceiveStreamObs => _didReceiveStream; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSProgress progress)> DidStartReceivingResourceObs => _didStartReceivingResource; + /// + public override void DidChangeState(global::MultipeerConnectivity.MCSession session, global::MultipeerConnectivity.MCPeerID peerID, global::MultipeerConnectivity.MCSessionState state) => _didChangeState.OnNext((session, peerID, state)); + /// + public override void DidFinishReceivingResource(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSUrl localUrl, global::Foundation.NSError error) => _didFinishReceivingResource.OnNext((session, resourceName, fromPeer, localUrl, error)); + /// + public override void DidReceiveData(global::MultipeerConnectivity.MCSession session, global::Foundation.NSData data, global::MultipeerConnectivity.MCPeerID peerID) => _didReceiveData.OnNext((session, data, peerID)); + /// + public override void DidReceiveStream(global::MultipeerConnectivity.MCSession session, global::Foundation.NSInputStream stream, string streamName, global::MultipeerConnectivity.MCPeerID peerID) => _didReceiveStream.OnNext((session, stream, streamName, peerID)); + /// + public override void DidStartReceivingResource(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSProgress progress) => _didStartReceivingResource.OnNext((session, resourceName, fromPeer, progress)); + } +} + +namespace NearbyInteraction +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class NISessionDelegateRx : global::NearbyInteraction.NISessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::NearbyInteraction.NISession session, global::Foundation.NSError error)> _didSessionInvalidate = new Pharmacist.Common.SingleAwaitSubject<(global::NearbyInteraction.NISession session, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::NearbyInteraction.NISession session, global::NearbyInteraction.NINearbyObject[] nearbyObjects, global::NearbyInteraction.NINearbyObjectRemovalReason reason)> _didSessionRemoveNearbyObjects = new Pharmacist.Common.SingleAwaitSubject<(global::NearbyInteraction.NISession session, global::NearbyInteraction.NINearbyObject[] nearbyObjects, global::NearbyInteraction.NINearbyObjectRemovalReason reason)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::NearbyInteraction.NISession session, global::NearbyInteraction.NINearbyObject[] nearbyObjects)> _didSessionUpdateNearbyObjects = new Pharmacist.Common.SingleAwaitSubject<(global::NearbyInteraction.NISession session, global::NearbyInteraction.NINearbyObject[] nearbyObjects)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _sessionSuspensionEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _sessionWasSuspended = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::NearbyInteraction.NISession session, global::Foundation.NSError error)> DidSessionInvalidateObs => _didSessionInvalidate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::NearbyInteraction.NISession session, global::NearbyInteraction.NINearbyObject[] nearbyObjects, global::NearbyInteraction.NINearbyObjectRemovalReason reason)> DidSessionRemoveNearbyObjectsObs => _didSessionRemoveNearbyObjects; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::NearbyInteraction.NISession session, global::NearbyInteraction.NINearbyObject[] nearbyObjects)> DidSessionUpdateNearbyObjectsObs => _didSessionUpdateNearbyObjects; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SessionSuspensionEndedObs => _sessionSuspensionEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SessionWasSuspendedObs => _sessionWasSuspended; + /// + public override void DidSessionInvalidate(global::NearbyInteraction.NISession session, global::Foundation.NSError error) => _didSessionInvalidate.OnNext((session, error)); + /// + public override void DidSessionRemoveNearbyObjects(global::NearbyInteraction.NISession session, global::NearbyInteraction.NINearbyObject[] nearbyObjects, global::NearbyInteraction.NINearbyObjectRemovalReason reason) => _didSessionRemoveNearbyObjects.OnNext((session, nearbyObjects, reason)); + /// + public override void DidSessionUpdateNearbyObjects(global::NearbyInteraction.NISession session, global::NearbyInteraction.NINearbyObject[] nearbyObjects) => _didSessionUpdateNearbyObjects.OnNext((session, nearbyObjects)); + /// + public override void SessionSuspensionEnded(global::NearbyInteraction.NISession session) => _sessionSuspensionEnded.OnNext(session); + /// + public override void SessionWasSuspended(global::NearbyInteraction.NISession session) => _sessionWasSuspended.OnNext(session); + } +} + +namespace NetworkExtension +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NEAppPushDelegateRx : global::NetworkExtension.NEAppPushDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::NetworkExtension.NEAppPushManager manager, global::Foundation.NSDictionary userInfo)> _didReceiveIncomingCall = new Pharmacist.Common.SingleAwaitSubject<(global::NetworkExtension.NEAppPushManager manager, global::Foundation.NSDictionary userInfo)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::NetworkExtension.NEAppPushManager manager, global::Foundation.NSDictionary userInfo)> DidReceiveIncomingCallObs => _didReceiveIncomingCall; + /// + public override void DidReceiveIncomingCall(global::NetworkExtension.NEAppPushManager manager, global::Foundation.NSDictionary userInfo) => _didReceiveIncomingCall.OnNext((manager, userInfo)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NWTcpConnectionAuthenticationDelegateRx : global::NetworkExtension.NWTcpConnectionAuthenticationDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::NetworkExtension.NWTcpConnection connection, global::Foundation.NSArray peerCertificateChain, global::System.Action completion)> _evaluateTrust = new Pharmacist.Common.SingleAwaitSubject<(global::NetworkExtension.NWTcpConnection connection, global::Foundation.NSArray peerCertificateChain, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::NetworkExtension.NWTcpConnection connection, global::System.Action completion)> _provideIdentity = new Pharmacist.Common.SingleAwaitSubject<(global::NetworkExtension.NWTcpConnection connection, global::System.Action completion)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::NetworkExtension.NWTcpConnection connection, global::Foundation.NSArray peerCertificateChain, global::System.Action completion)> EvaluateTrustObs => _evaluateTrust; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::NetworkExtension.NWTcpConnection connection, global::System.Action completion)> ProvideIdentityObs => _provideIdentity; + /// + public override void EvaluateTrust(global::NetworkExtension.NWTcpConnection connection, global::Foundation.NSArray peerCertificateChain, global::System.Action completion) => _evaluateTrust.OnNext((connection, peerCertificateChain, completion)); + /// + public override void ProvideIdentity(global::NetworkExtension.NWTcpConnection connection, global::System.Action completion) => _provideIdentity.OnNext((connection, completion)); + } +} + +namespace PassKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class PKAddPassesViewControllerDelegateRx : global::PassKit.PKAddPassesViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _finished = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedObs => _finished; + /// + public override void Finished(global::PassKit.PKAddPassesViewController controller) => _finished.OnNext(controller); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class PKAddPaymentPassViewControllerDelegateRx : global::PassKit.PKAddPaymentPassViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKAddPaymentPassViewController controller, global::PassKit.PKPaymentPass pass, global::Foundation.NSError error)> _didFinishAddingPaymentPass = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKAddPaymentPassViewController controller, global::PassKit.PKPaymentPass pass, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKAddPaymentPassViewController controller, global::Foundation.NSData[] certificates, global::Foundation.NSData nonce, global::Foundation.NSData nonceSignature, global::System.Action handler)> _generateRequestWithCertificateChain = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKAddPaymentPassViewController controller, global::Foundation.NSData[] certificates, global::Foundation.NSData nonce, global::Foundation.NSData nonceSignature, global::System.Action handler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKAddPaymentPassViewController controller, global::PassKit.PKPaymentPass pass, global::Foundation.NSError error)> DidFinishAddingPaymentPassObs => _didFinishAddingPaymentPass; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKAddPaymentPassViewController controller, global::Foundation.NSData[] certificates, global::Foundation.NSData nonce, global::Foundation.NSData nonceSignature, global::System.Action handler)> GenerateRequestWithCertificateChainObs => _generateRequestWithCertificateChain; + /// + public override void DidFinishAddingPaymentPass(global::PassKit.PKAddPaymentPassViewController controller, global::PassKit.PKPaymentPass pass, global::Foundation.NSError error) => _didFinishAddingPaymentPass.OnNext((controller, pass, error)); + /// + public override void GenerateRequestWithCertificateChain(global::PassKit.PKAddPaymentPassViewController controller, global::Foundation.NSData[] certificates, global::Foundation.NSData nonce, global::Foundation.NSData nonceSignature, global::System.Action handler) => _generateRequestWithCertificateChain.OnNext((controller, certificates, nonce, nonceSignature, handler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class PKAddSecureElementPassViewControllerDelegateRx : global::PassKit.PKAddSecureElementPassViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKAddSecureElementPassViewController controller, global::PassKit.PKSecureElementPass pass, global::Foundation.NSError error)> _didFinishAddingSecureElementPass = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKAddSecureElementPassViewController controller, global::PassKit.PKSecureElementPass pass, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKAddSecureElementPassViewController controller, global::PassKit.PKSecureElementPass[] passes, global::Foundation.NSError error)> _didFinishAddingSecureElementPasses = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKAddSecureElementPassViewController controller, global::PassKit.PKSecureElementPass[] passes, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKAddSecureElementPassViewController controller, global::PassKit.PKSecureElementPass pass, global::Foundation.NSError error)> DidFinishAddingSecureElementPassObs => _didFinishAddingSecureElementPass; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKAddSecureElementPassViewController controller, global::PassKit.PKSecureElementPass[] passes, global::Foundation.NSError error)> DidFinishAddingSecureElementPassesObs => _didFinishAddingSecureElementPasses; + /// + public override void DidFinishAddingSecureElementPass(global::PassKit.PKAddSecureElementPassViewController controller, global::PassKit.PKSecureElementPass pass, global::Foundation.NSError error) => _didFinishAddingSecureElementPass.OnNext((controller, pass, error)); + /// + public override void DidFinishAddingSecureElementPasses(global::PassKit.PKAddSecureElementPassViewController controller, global::PassKit.PKSecureElementPass[] passes, global::Foundation.NSError error) => _didFinishAddingSecureElementPasses.OnNext((controller, passes, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class PKDisbursementAuthorizationControllerDelegateRx : global::PassKit.PKDisbursementAuthorizationControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKDisbursementAuthorizationController controller, global::PassKit.PKDisbursementVoucher disbursementVoucher)> _didAuthorize = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKDisbursementAuthorizationController controller, global::PassKit.PKDisbursementVoucher disbursementVoucher)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinish = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKDisbursementAuthorizationController controller, global::PassKit.PKDisbursementVoucher disbursementVoucher)> DidAuthorizeObs => _didAuthorize; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishObs => _didFinish; + /// + public override void DidAuthorize(global::PassKit.PKDisbursementAuthorizationController controller, global::PassKit.PKDisbursementVoucher disbursementVoucher) => _didAuthorize.OnNext((controller, disbursementVoucher)); + /// + public override void DidFinish(global::PassKit.PKDisbursementAuthorizationController controller) => _didFinish.OnNext(controller); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class PKPaymentAuthorizationControllerDelegateRx : global::PassKit.PKPaymentAuthorizationControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPayment payment, global::System.Action completion)> _didAuthorizePayment = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPayment payment, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinish = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::System.Action handler)> _didRequestMerchantSessionUpdate = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::System.Action handler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)> _didSelectPaymentMethod = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKContact contact, global::System.Action completion)> _didSelectShippingContact = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKContact contact, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion)> _didSelectShippingMethod = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willAuthorizePayment = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPayment payment, global::System.Action completion)> DidAuthorizePaymentObs => _didAuthorizePayment; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishObs => _didFinish; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationController controller, global::System.Action handler)> DidRequestMerchantSessionUpdateObs => _didRequestMerchantSessionUpdate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)> DidSelectPaymentMethodObs => _didSelectPaymentMethod; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKContact contact, global::System.Action completion)> DidSelectShippingContactObs => _didSelectShippingContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion)> DidSelectShippingMethodObs => _didSelectShippingMethod; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillAuthorizePaymentObs => _willAuthorizePayment; + /// + public override void DidAuthorizePayment(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPayment payment, global::System.Action completion) => _didAuthorizePayment.OnNext((controller, payment, completion)); + /// + public override void DidFinish(global::PassKit.PKPaymentAuthorizationController controller) => _didFinish.OnNext(controller); + /// + public override void DidRequestMerchantSessionUpdate(global::PassKit.PKPaymentAuthorizationController controller, global::System.Action handler) => _didRequestMerchantSessionUpdate.OnNext((controller, handler)); + /// + public override void DidSelectPaymentMethod(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion) => _didSelectPaymentMethod.OnNext((controller, paymentMethod, completion)); + /// + public override void DidSelectShippingContact(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKContact contact, global::System.Action completion) => _didSelectShippingContact.OnNext((controller, contact, completion)); + /// + public override void DidSelectShippingMethod(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion) => _didSelectShippingMethod.OnNext((controller, shippingMethod, completion)); + /// + public override void WillAuthorizePayment(global::PassKit.PKPaymentAuthorizationController controller) => _willAuthorizePayment.OnNext(controller); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class PKPaymentAuthorizationViewControllerDelegateRx : global::PassKit.PKPaymentAuthorizationViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPayment payment, global::System.Action completion)> _didAuthorizePayment = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPayment payment, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPayment payment, global::System.Action completion)> _didAuthorizePayment2 = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPayment payment, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::System.Action updateHandler)> _didRequestMerchantSessionUpdate = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::System.Action updateHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)> _didSelectPaymentMethod = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)> _didSelectPaymentMethod2 = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::AddressBook.ABRecord address, global::PassKit.PKPaymentShippingAddressSelected completion)> _didSelectShippingAddress = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::AddressBook.ABRecord address, global::PassKit.PKPaymentShippingAddressSelected completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKContact contact, global::PassKit.PKPaymentShippingAddressSelected completion)> _didSelectShippingContact = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKContact contact, global::PassKit.PKPaymentShippingAddressSelected completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKContact contact, global::System.Action completion)> _didSelectShippingContact2 = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKContact contact, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKShippingMethod shippingMethod, global::PassKit.PKPaymentShippingMethodSelected completion)> _didSelectShippingMethod = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKShippingMethod shippingMethod, global::PassKit.PKPaymentShippingMethodSelected completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion)> _didSelectShippingMethod2 = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _paymentAuthorizationViewControllerDidFinish = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willAuthorizePayment = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPayment payment, global::System.Action completion)> DidAuthorizePaymentObs => _didAuthorizePayment; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPayment payment, global::System.Action completion)> DidAuthorizePayment2Obs => _didAuthorizePayment2; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationViewController controller, global::System.Action updateHandler)> DidRequestMerchantSessionUpdateObs => _didRequestMerchantSessionUpdate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)> DidSelectPaymentMethodObs => _didSelectPaymentMethod; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)> DidSelectPaymentMethod2Obs => _didSelectPaymentMethod2; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationViewController controller, global::AddressBook.ABRecord address, global::PassKit.PKPaymentShippingAddressSelected completion)> DidSelectShippingAddressObs => _didSelectShippingAddress; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKContact contact, global::PassKit.PKPaymentShippingAddressSelected completion)> DidSelectShippingContactObs => _didSelectShippingContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKContact contact, global::System.Action completion)> DidSelectShippingContact2Obs => _didSelectShippingContact2; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKShippingMethod shippingMethod, global::PassKit.PKPaymentShippingMethodSelected completion)> DidSelectShippingMethodObs => _didSelectShippingMethod; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion)> DidSelectShippingMethod2Obs => _didSelectShippingMethod2; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PaymentAuthorizationViewControllerDidFinishObs => _paymentAuthorizationViewControllerDidFinish; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillAuthorizePaymentObs => _willAuthorizePayment; + /// + public override void DidAuthorizePayment(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPayment payment, global::System.Action completion) => _didAuthorizePayment.OnNext((controller, payment, completion)); + /// + public override void DidAuthorizePayment2(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPayment payment, global::System.Action completion) => _didAuthorizePayment2.OnNext((controller, payment, completion)); + /// + public override void DidRequestMerchantSessionUpdate(global::PassKit.PKPaymentAuthorizationViewController controller, global::System.Action updateHandler) => _didRequestMerchantSessionUpdate.OnNext((controller, updateHandler)); + /// + public override void DidSelectPaymentMethod(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion) => _didSelectPaymentMethod.OnNext((controller, paymentMethod, completion)); + /// + public override void DidSelectPaymentMethod2(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion) => _didSelectPaymentMethod2.OnNext((controller, paymentMethod, completion)); + /// + public override void DidSelectShippingAddress(global::PassKit.PKPaymentAuthorizationViewController controller, global::AddressBook.ABRecord address, global::PassKit.PKPaymentShippingAddressSelected completion) => _didSelectShippingAddress.OnNext((controller, address, completion)); + /// + public override void DidSelectShippingContact(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKContact contact, global::PassKit.PKPaymentShippingAddressSelected completion) => _didSelectShippingContact.OnNext((controller, contact, completion)); + /// + public override void DidSelectShippingContact2(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKContact contact, global::System.Action completion) => _didSelectShippingContact2.OnNext((controller, contact, completion)); + /// + public override void DidSelectShippingMethod(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKShippingMethod shippingMethod, global::PassKit.PKPaymentShippingMethodSelected completion) => _didSelectShippingMethod.OnNext((controller, shippingMethod, completion)); + /// + public override void DidSelectShippingMethod2(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion) => _didSelectShippingMethod2.OnNext((controller, shippingMethod, completion)); + /// + public override void PaymentAuthorizationViewControllerDidFinish(global::PassKit.PKPaymentAuthorizationViewController controller) => _paymentAuthorizationViewControllerDidFinish.OnNext(controller); + /// + public override void WillAuthorizePayment(global::PassKit.PKPaymentAuthorizationViewController controller) => _willAuthorizePayment.OnNext(controller); + } +} + +namespace PdfKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class PdfDocumentDelegateRx : global::PdfKit.PdfDocumentDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBeginDocumentFind = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didMatchString = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUnlock = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _findFinished = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _matchFound = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _pageFindFinished = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _pageFindStarted = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBeginDocumentFindObs => _didBeginDocumentFind; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidMatchStringObs => _didMatchString; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUnlockObs => _didUnlock; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FindFinishedObs => _findFinished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable MatchFoundObs => _matchFound; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PageFindFinishedObs => _pageFindFinished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PageFindStartedObs => _pageFindStarted; + /// + public override void DidBeginDocumentFind(global::Foundation.NSNotification notification) => _didBeginDocumentFind.OnNext(notification); + /// + public override void DidMatchString(global::PdfKit.PdfSelection sender) => _didMatchString.OnNext(sender); + /// + public override void DidUnlock(global::Foundation.NSNotification notification) => _didUnlock.OnNext(notification); + /// + public override void FindFinished(global::Foundation.NSNotification notification) => _findFinished.OnNext(notification); + /// + public override void MatchFound(global::Foundation.NSNotification notification) => _matchFound.OnNext(notification); + /// + public override void PageFindFinished(global::Foundation.NSNotification notification) => _pageFindFinished.OnNext(notification); + /// + public override void PageFindStarted(global::Foundation.NSNotification notification) => _pageFindStarted.OnNext(notification); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class PdfViewDelegateRx : global::PdfKit.PdfViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PdfKit.PdfView sender, global::PdfKit.PdfActionRemoteGoTo action)> _openPdf = new Pharmacist.Common.SingleAwaitSubject<(global::PdfKit.PdfView sender, global::PdfKit.PdfActionRemoteGoTo action)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _performFind = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _performGoToPage = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PdfKit.PdfView sender, global::Foundation.NSUrl url)> _willClickOnLink = new Pharmacist.Common.SingleAwaitSubject<(global::PdfKit.PdfView sender, global::Foundation.NSUrl url)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PdfKit.PdfView sender, global::PdfKit.PdfActionRemoteGoTo action)> OpenPdfObs => _openPdf; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PerformFindObs => _performFind; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PerformGoToPageObs => _performGoToPage; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PdfKit.PdfView sender, global::Foundation.NSUrl url)> WillClickOnLinkObs => _willClickOnLink; + /// + public override void OpenPdf(global::PdfKit.PdfView sender, global::PdfKit.PdfActionRemoteGoTo action) => _openPdf.OnNext((sender, action)); + /// + public override void PerformFind(global::PdfKit.PdfView sender) => _performFind.OnNext(sender); + /// + public override void PerformGoToPage(global::PdfKit.PdfView sender) => _performGoToPage.OnNext(sender); + /// + public override void WillClickOnLink(global::PdfKit.PdfView sender, global::Foundation.NSUrl url) => _willClickOnLink.OnNext((sender, url)); + } +} + +namespace PencilKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class PKCanvasViewDelegateRx : global::PencilKit.PKCanvasViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _decelerationEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _decelerationStarted = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didBeginUsingTool = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeAdjustedContentInset = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinishRendering = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didZoom = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, bool willDecelerate)> _draggingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, bool willDecelerate)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _draggingStarted = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _drawingDidChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _endUsingTool = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _scrollAnimationEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _scrolled = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _scrolledToTop = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView withView, global::System.nfloat atScale)> _zoomingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView withView, global::System.nfloat atScale)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView view)> _zoomingStarted = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView view)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DecelerationEndedObs => _decelerationEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DecelerationStartedObs => _decelerationStarted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBeginUsingToolObs => _didBeginUsingTool; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeAdjustedContentInsetObs => _didChangeAdjustedContentInset; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishRenderingObs => _didFinishRendering; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidZoomObs => _didZoom; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScrollView scrollView, bool willDecelerate)> DraggingEndedObs => _draggingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DraggingStartedObs => _draggingStarted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DrawingDidChangeObs => _drawingDidChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable EndUsingToolObs => _endUsingTool; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ScrollAnimationEndedObs => _scrollAnimationEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ScrolledObs => _scrolled; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ScrolledToTopObs => _scrolledToTop; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView withView, global::System.nfloat atScale)> ZoomingEndedObs => _zoomingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView view)> ZoomingStartedObs => _zoomingStarted; + /// + public override void DecelerationEnded(global::UIKit.UIScrollView scrollView) => _decelerationEnded.OnNext(scrollView); + /// + public override void DecelerationStarted(global::UIKit.UIScrollView scrollView) => _decelerationStarted.OnNext(scrollView); + /// + public override void DidBeginUsingTool(global::PencilKit.PKCanvasView canvasView) => _didBeginUsingTool.OnNext(canvasView); + /// + public override void DidChangeAdjustedContentInset(global::UIKit.UIScrollView scrollView) => _didChangeAdjustedContentInset.OnNext(scrollView); + /// + public override void DidFinishRendering(global::PencilKit.PKCanvasView canvasView) => _didFinishRendering.OnNext(canvasView); + /// + public override void DidZoom(global::UIKit.UIScrollView scrollView) => _didZoom.OnNext(scrollView); + /// + public override void DraggingEnded(global::UIKit.UIScrollView scrollView, bool willDecelerate) => _draggingEnded.OnNext((scrollView, willDecelerate)); + /// + public override void DraggingStarted(global::UIKit.UIScrollView scrollView) => _draggingStarted.OnNext(scrollView); + /// + public override void DrawingDidChange(global::PencilKit.PKCanvasView canvasView) => _drawingDidChange.OnNext(canvasView); + /// + public override void EndUsingTool(global::PencilKit.PKCanvasView canvasView) => _endUsingTool.OnNext(canvasView); + /// + public override void ScrollAnimationEnded(global::UIKit.UIScrollView scrollView) => _scrollAnimationEnded.OnNext(scrollView); + /// + public override void Scrolled(global::UIKit.UIScrollView scrollView) => _scrolled.OnNext(scrollView); + /// + public override void ScrolledToTop(global::UIKit.UIScrollView scrollView) => _scrolledToTop.OnNext(scrollView); + /// + public override void ZoomingEnded(global::UIKit.UIScrollView scrollView, global::UIKit.UIView withView, global::System.nfloat atScale) => _zoomingEnded.OnNext((scrollView, withView, atScale)); + /// + public override void ZoomingStarted(global::UIKit.UIScrollView scrollView, global::UIKit.UIView view) => _zoomingStarted.OnNext((scrollView, view)); + } +} + +namespace PhotosUI +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class PHLivePhotoViewDelegateRx : global::PhotosUI.PHLivePhotoViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle)> _didEndPlayback = new Pharmacist.Common.SingleAwaitSubject<(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle)> _willBeginPlayback = new Pharmacist.Common.SingleAwaitSubject<(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle)> DidEndPlaybackObs => _didEndPlayback; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle)> WillBeginPlaybackObs => _willBeginPlayback; + /// + public override void DidEndPlayback(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle) => _didEndPlayback.OnNext((livePhotoView, playbackStyle)); + /// + public override void WillBeginPlayback(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle) => _willBeginPlayback.OnNext((livePhotoView, playbackStyle)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class PHPickerViewControllerDelegateRx : global::PhotosUI.PHPickerViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PhotosUI.PHPickerViewController picker, global::PhotosUI.PHPickerResult[] results)> _didFinishPicking = new Pharmacist.Common.SingleAwaitSubject<(global::PhotosUI.PHPickerViewController picker, global::PhotosUI.PHPickerResult[] results)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PhotosUI.PHPickerViewController picker, global::PhotosUI.PHPickerResult[] results)> DidFinishPickingObs => _didFinishPicking; + /// + public override void DidFinishPicking(global::PhotosUI.PHPickerViewController picker, global::PhotosUI.PHPickerResult[] results) => _didFinishPicking.OnNext((picker, results)); + } +} + +namespace PushKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class PKPushRegistryDelegateRx : global::PushKit.PKPushRegistryDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, string type)> _didInvalidatePushToken = new Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, string type)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushPayload payload, string type, global::System.Action completion)> _didReceiveIncomingPush = new Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushPayload payload, string type, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushCredentials credentials, string type)> _didUpdatePushCredentials = new Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushCredentials credentials, string type)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PushKit.PKPushRegistry registry, string type)> DidInvalidatePushTokenObs => _didInvalidatePushToken; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushPayload payload, string type, global::System.Action completion)> DidReceiveIncomingPushObs => _didReceiveIncomingPush; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushCredentials credentials, string type)> DidUpdatePushCredentialsObs => _didUpdatePushCredentials; + /// + public override void DidInvalidatePushToken(global::PushKit.PKPushRegistry registry, string type) => _didInvalidatePushToken.OnNext((registry, type)); + /// + public override void DidReceiveIncomingPush(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushPayload payload, string type, global::System.Action completion) => _didReceiveIncomingPush.OnNext((registry, payload, type, completion)); + /// + public override void DidUpdatePushCredentials(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushCredentials credentials, string type) => _didUpdatePushCredentials.OnNext((registry, credentials, type)); + } +} + +namespace QuickLook +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class QLPreviewControllerDelegateRx : global::QuickLook.QLPreviewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didDismiss = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::QuickLook.QLPreviewController controller, global::QuickLook.IQLPreviewItem previewItem, global::Foundation.NSUrl modifiedContentsUrl)> _didSaveEditedCopy = new Pharmacist.Common.SingleAwaitSubject<(global::QuickLook.QLPreviewController controller, global::QuickLook.IQLPreviewItem previewItem, global::Foundation.NSUrl modifiedContentsUrl)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::QuickLook.QLPreviewController controller, global::QuickLook.IQLPreviewItem previewItem)> _didUpdateContents = new Pharmacist.Common.SingleAwaitSubject<(global::QuickLook.QLPreviewController controller, global::QuickLook.IQLPreviewItem previewItem)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willDismiss = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDismissObs => _didDismiss; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::QuickLook.QLPreviewController controller, global::QuickLook.IQLPreviewItem previewItem, global::Foundation.NSUrl modifiedContentsUrl)> DidSaveEditedCopyObs => _didSaveEditedCopy; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::QuickLook.QLPreviewController controller, global::QuickLook.IQLPreviewItem previewItem)> DidUpdateContentsObs => _didUpdateContents; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillDismissObs => _willDismiss; + /// + public override void DidDismiss(global::QuickLook.QLPreviewController controller) => _didDismiss.OnNext(controller); + /// + public override void DidSaveEditedCopy(global::QuickLook.QLPreviewController controller, global::QuickLook.IQLPreviewItem previewItem, global::Foundation.NSUrl modifiedContentsUrl) => _didSaveEditedCopy.OnNext((controller, previewItem, modifiedContentsUrl)); + /// + public override void DidUpdateContents(global::QuickLook.QLPreviewController controller, global::QuickLook.IQLPreviewItem previewItem) => _didUpdateContents.OnNext((controller, previewItem)); + /// + public override void WillDismiss(global::QuickLook.QLPreviewController controller) => _willDismiss.OnNext(controller); + } +} + +namespace ReplayKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class RPBroadcastActivityViewControllerDelegateRx : global::ReplayKit.RPBroadcastActivityViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastActivityViewController broadcastActivityViewController, global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error)> _didFinish = new Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastActivityViewController broadcastActivityViewController, global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ReplayKit.RPBroadcastActivityViewController broadcastActivityViewController, global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error)> DidFinishObs => _didFinish; + /// + public override void DidFinish(global::ReplayKit.RPBroadcastActivityViewController broadcastActivityViewController, global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error) => _didFinish.OnNext((broadcastActivityViewController, broadcastController, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class RPBroadcastControllerDelegateRx : global::ReplayKit.RPBroadcastControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error)> _didFinish = new Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSUrl broadcastUrl)> _didUpdateBroadcastUrl = new Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSUrl broadcastUrl)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSDictionary serviceInfo)> _didUpdateServiceInfo = new Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSDictionary serviceInfo)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error)> DidFinishObs => _didFinish; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSUrl broadcastUrl)> DidUpdateBroadcastUrlObs => _didUpdateBroadcastUrl; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSDictionary serviceInfo)> DidUpdateServiceInfoObs => _didUpdateServiceInfo; + /// + public override void DidFinish(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error) => _didFinish.OnNext((broadcastController, error)); + /// + public override void DidUpdateBroadcastUrl(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSUrl broadcastUrl) => _didUpdateBroadcastUrl.OnNext((broadcastController, broadcastUrl)); + /// + public override void DidUpdateServiceInfo(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSDictionary serviceInfo) => _didUpdateServiceInfo.OnNext((broadcastController, serviceInfo)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class RPPreviewViewControllerDelegateRx : global::ReplayKit.RPPreviewViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPPreviewViewController previewController, global::Foundation.NSSet activityTypes)> _didFinish = new Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPPreviewViewController previewController, global::Foundation.NSSet activityTypes)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ReplayKit.RPPreviewViewController previewController, global::Foundation.NSSet activityTypes)> DidFinishObs => _didFinish; + /// + public override void DidFinish(global::ReplayKit.RPPreviewViewController previewController, global::Foundation.NSSet activityTypes) => _didFinish.OnNext((previewController, activityTypes)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class RPScreenRecorderDelegateRx : global::ReplayKit.RPScreenRecorderDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeAvailability = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPScreenRecorder screenRecorder, global::Foundation.NSError error, global::ReplayKit.RPPreviewViewController previewViewController)> _didStopRecording = new Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPScreenRecorder screenRecorder, global::Foundation.NSError error, global::ReplayKit.RPPreviewViewController previewViewController)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeAvailabilityObs => _didChangeAvailability; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ReplayKit.RPScreenRecorder screenRecorder, global::Foundation.NSError error, global::ReplayKit.RPPreviewViewController previewViewController)> DidStopRecordingObs => _didStopRecording; + /// + public override void DidChangeAvailability(global::ReplayKit.RPScreenRecorder screenRecorder) => _didChangeAvailability.OnNext(screenRecorder); + /// + public override void DidStopRecording(global::ReplayKit.RPScreenRecorder screenRecorder, global::Foundation.NSError error, global::ReplayKit.RPPreviewViewController previewViewController) => _didStopRecording.OnNext((screenRecorder, error, previewViewController)); + } +} + +namespace SafariServices +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class SFSafariViewControllerDelegateRx : global::SafariServices.SFSafariViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SafariServices.SFSafariViewController controller, bool didLoadSuccessfully)> _didCompleteInitialLoad = new Pharmacist.Common.SingleAwaitSubject<(global::SafariServices.SFSafariViewController controller, bool didLoadSuccessfully)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinish = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SafariServices.SFSafariViewController controller, global::Foundation.NSUrl url)> _initialLoadDidRedirectToUrl = new Pharmacist.Common.SingleAwaitSubject<(global::SafariServices.SFSafariViewController controller, global::Foundation.NSUrl url)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willOpenInBrowser = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SafariServices.SFSafariViewController controller, bool didLoadSuccessfully)> DidCompleteInitialLoadObs => _didCompleteInitialLoad; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishObs => _didFinish; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SafariServices.SFSafariViewController controller, global::Foundation.NSUrl url)> InitialLoadDidRedirectToUrlObs => _initialLoadDidRedirectToUrl; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillOpenInBrowserObs => _willOpenInBrowser; + /// + public override void DidCompleteInitialLoad(global::SafariServices.SFSafariViewController controller, bool didLoadSuccessfully) => _didCompleteInitialLoad.OnNext((controller, didLoadSuccessfully)); + /// + public override void DidFinish(global::SafariServices.SFSafariViewController controller) => _didFinish.OnNext(controller); + /// + public override void InitialLoadDidRedirectToUrl(global::SafariServices.SFSafariViewController controller, global::Foundation.NSUrl url) => _initialLoadDidRedirectToUrl.OnNext((controller, url)); + /// + public override void WillOpenInBrowser(global::SafariServices.SFSafariViewController controller) => _willOpenInBrowser.OnNext(controller); + } +} + +namespace SceneKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNAvoidOccluderConstraintDelegateRx : global::SceneKit.SCNAvoidOccluderConstraintDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNAvoidOccluderConstraint constraint, global::SceneKit.SCNNode occluder, global::SceneKit.SCNNode node)> _didAvoidOccluder = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNAvoidOccluderConstraint constraint, global::SceneKit.SCNNode occluder, global::SceneKit.SCNNode node)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNAvoidOccluderConstraint constraint, global::SceneKit.SCNNode occluder, global::SceneKit.SCNNode node)> DidAvoidOccluderObs => _didAvoidOccluder; + /// + public override void DidAvoidOccluder(global::SceneKit.SCNAvoidOccluderConstraint constraint, global::SceneKit.SCNNode occluder, global::SceneKit.SCNNode node) => _didAvoidOccluder.OnNext((constraint, occluder, node)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNCameraControllerDelegateRx : global::SceneKit.SCNCameraControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _cameraInertiaDidEnd = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _cameraInertiaWillStart = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable CameraInertiaDidEndObs => _cameraInertiaDidEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable CameraInertiaWillStartObs => _cameraInertiaWillStart; + /// + public override void CameraInertiaDidEnd(global::SceneKit.SCNCameraController cameraController) => _cameraInertiaDidEnd.OnNext(cameraController); + /// + public override void CameraInertiaWillStart(global::SceneKit.SCNCameraController cameraController) => _cameraInertiaWillStart.OnNext(cameraController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNNodeRendererDelegateRx : global::SceneKit.SCNNodeRendererDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNNode node, global::SceneKit.SCNRenderer renderer, global::Foundation.NSDictionary arguments)> _render = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNNode node, global::SceneKit.SCNRenderer renderer, global::Foundation.NSDictionary arguments)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNNode node, global::SceneKit.SCNRenderer renderer, global::Foundation.NSDictionary arguments)> RenderObs => _render; + /// + public override void Render(global::SceneKit.SCNNode node, global::SceneKit.SCNRenderer renderer, global::Foundation.NSDictionary arguments) => _render.OnNext((node, renderer, arguments)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNPhysicsContactDelegateRx : global::SceneKit.SCNPhysicsContactDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> _didBeginContact = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> _didEndContact = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> _didUpdateContact = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> DidBeginContactObs => _didBeginContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> DidEndContactObs => _didEndContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> DidUpdateContactObs => _didUpdateContact; + /// + public override void DidBeginContact(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact) => _didBeginContact.OnNext((world, contact)); + /// + public override void DidEndContact(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact) => _didEndContact.OnNext((world, contact)); + /// + public override void DidUpdateContact(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact) => _didUpdateContact.OnNext((world, contact)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNProgramDelegateRx : global::SceneKit.SCNProgramDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNProgram program, global::Foundation.NSError error)> _handleError = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNProgram program, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNProgram program, global::Foundation.NSError error)> HandleErrorObs => _handleError; + /// + public override void HandleError(global::SceneKit.SCNProgram program, global::Foundation.NSError error) => _handleError.OnNext((program, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNSceneRendererDelegateRx : global::SceneKit.SCNSceneRendererDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> _didApplyAnimations = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double atTime)> _didApplyConstraints = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double atTime)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> _didRenderScene = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> _didSimulatePhysics = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> _update = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> _willRenderScene = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> DidApplyAnimationsObs => _didApplyAnimations; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double atTime)> DidApplyConstraintsObs => _didApplyConstraints; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> DidRenderSceneObs => _didRenderScene; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> DidSimulatePhysicsObs => _didSimulatePhysics; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> UpdateObs => _update; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> WillRenderSceneObs => _willRenderScene; + /// + public override void DidApplyAnimations(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds) => _didApplyAnimations.OnNext((renderer, timeInSeconds)); + /// + public override void DidApplyConstraints(global::SceneKit.ISCNSceneRenderer renderer, double atTime) => _didApplyConstraints.OnNext((renderer, atTime)); + /// + public override void DidRenderScene(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds) => _didRenderScene.OnNext((renderer, scene, timeInSeconds)); + /// + public override void DidSimulatePhysics(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds) => _didSimulatePhysics.OnNext((renderer, timeInSeconds)); + /// + public override void Update(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds) => _update.OnNext((renderer, timeInSeconds)); + /// + public override void WillRenderScene(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds) => _willRenderScene.OnNext((renderer, scene, timeInSeconds)); + } +} + +namespace SensorKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class SRSensorReaderDelegateRx : global::SensorKit.SRSensorReaderDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SensorKit.SRSensorReader reader, global::SensorKit.SRAuthorizationStatus authorizationStatus)> _didChangeAuthorizationStatus = new Pharmacist.Common.SingleAwaitSubject<(global::SensorKit.SRSensorReader reader, global::SensorKit.SRAuthorizationStatus authorizationStatus)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SensorKit.SRSensorReader reader, global::SensorKit.SRFetchRequest fetchRequest)> _didCompleteFetch = new Pharmacist.Common.SingleAwaitSubject<(global::SensorKit.SRSensorReader reader, global::SensorKit.SRFetchRequest fetchRequest)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SensorKit.SRSensorReader reader, global::SensorKit.SRDevice[] devices)> _didFetchDevices = new Pharmacist.Common.SingleAwaitSubject<(global::SensorKit.SRSensorReader reader, global::SensorKit.SRDevice[] devices)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didStopRecording = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SensorKit.SRSensorReader reader, global::Foundation.NSError error)> _fetchDevicesFailed = new Pharmacist.Common.SingleAwaitSubject<(global::SensorKit.SRSensorReader reader, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SensorKit.SRSensorReader reader, global::SensorKit.SRFetchRequest fetchRequest, global::Foundation.NSError error)> _fetchingRequestFailed = new Pharmacist.Common.SingleAwaitSubject<(global::SensorKit.SRSensorReader reader, global::SensorKit.SRFetchRequest fetchRequest, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SensorKit.SRSensorReader reader, global::Foundation.NSError error)> _startRecordingFailed = new Pharmacist.Common.SingleAwaitSubject<(global::SensorKit.SRSensorReader reader, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SensorKit.SRSensorReader reader, global::Foundation.NSError error)> _stopRecordingFailed = new Pharmacist.Common.SingleAwaitSubject<(global::SensorKit.SRSensorReader reader, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStartRecording = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SensorKit.SRSensorReader reader, global::SensorKit.SRAuthorizationStatus authorizationStatus)> DidChangeAuthorizationStatusObs => _didChangeAuthorizationStatus; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SensorKit.SRSensorReader reader, global::SensorKit.SRFetchRequest fetchRequest)> DidCompleteFetchObs => _didCompleteFetch; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SensorKit.SRSensorReader reader, global::SensorKit.SRDevice[] devices)> DidFetchDevicesObs => _didFetchDevices; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidStopRecordingObs => _didStopRecording; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SensorKit.SRSensorReader reader, global::Foundation.NSError error)> FetchDevicesFailedObs => _fetchDevicesFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SensorKit.SRSensorReader reader, global::SensorKit.SRFetchRequest fetchRequest, global::Foundation.NSError error)> FetchingRequestFailedObs => _fetchingRequestFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SensorKit.SRSensorReader reader, global::Foundation.NSError error)> StartRecordingFailedObs => _startRecordingFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SensorKit.SRSensorReader reader, global::Foundation.NSError error)> StopRecordingFailedObs => _stopRecordingFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStartRecordingObs => _willStartRecording; + /// + public override void DidChangeAuthorizationStatus(global::SensorKit.SRSensorReader reader, global::SensorKit.SRAuthorizationStatus authorizationStatus) => _didChangeAuthorizationStatus.OnNext((reader, authorizationStatus)); + /// + public override void DidCompleteFetch(global::SensorKit.SRSensorReader reader, global::SensorKit.SRFetchRequest fetchRequest) => _didCompleteFetch.OnNext((reader, fetchRequest)); + /// + public override void DidFetchDevices(global::SensorKit.SRSensorReader reader, global::SensorKit.SRDevice[] devices) => _didFetchDevices.OnNext((reader, devices)); + /// + public override void DidStopRecording(global::SensorKit.SRSensorReader reader) => _didStopRecording.OnNext(reader); + /// + public override void FetchDevicesFailed(global::SensorKit.SRSensorReader reader, global::Foundation.NSError error) => _fetchDevicesFailed.OnNext((reader, error)); + /// + public override void FetchingRequestFailed(global::SensorKit.SRSensorReader reader, global::SensorKit.SRFetchRequest fetchRequest, global::Foundation.NSError error) => _fetchingRequestFailed.OnNext((reader, fetchRequest, error)); + /// + public override void StartRecordingFailed(global::SensorKit.SRSensorReader reader, global::Foundation.NSError error) => _startRecordingFailed.OnNext((reader, error)); + /// + public override void StopRecordingFailed(global::SensorKit.SRSensorReader reader, global::Foundation.NSError error) => _stopRecordingFailed.OnNext((reader, error)); + /// + public override void WillStartRecording(global::SensorKit.SRSensorReader reader) => _willStartRecording.OnNext(reader); + } +} + +namespace Speech +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class SFSpeechRecognitionTaskDelegateRx : global::Speech.SFSpeechRecognitionTaskDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didDetectSpeech = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFSpeechRecognitionResult recognitionResult)> _didFinishRecognition = new Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFSpeechRecognitionResult recognitionResult)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognitionTask task, bool successfully)> _didFinishSuccessfully = new Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognitionTask task, bool successfully)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFTranscription transcription)> _didHypothesizeTranscription = new Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFTranscription transcription)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _finishedReadingAudio = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _wasCancelled = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDetectSpeechObs => _didDetectSpeech; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFSpeechRecognitionResult recognitionResult)> DidFinishRecognitionObs => _didFinishRecognition; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Speech.SFSpeechRecognitionTask task, bool successfully)> DidFinishSuccessfullyObs => _didFinishSuccessfully; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFTranscription transcription)> DidHypothesizeTranscriptionObs => _didHypothesizeTranscription; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedReadingAudioObs => _finishedReadingAudio; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WasCancelledObs => _wasCancelled; + /// + public override void DidDetectSpeech(global::Speech.SFSpeechRecognitionTask task) => _didDetectSpeech.OnNext(task); + /// + public override void DidFinishRecognition(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFSpeechRecognitionResult recognitionResult) => _didFinishRecognition.OnNext((task, recognitionResult)); + /// + public override void DidFinishSuccessfully(global::Speech.SFSpeechRecognitionTask task, bool successfully) => _didFinishSuccessfully.OnNext((task, successfully)); + /// + public override void DidHypothesizeTranscription(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFTranscription transcription) => _didHypothesizeTranscription.OnNext((task, transcription)); + /// + public override void FinishedReadingAudio(global::Speech.SFSpeechRecognitionTask task) => _finishedReadingAudio.OnNext(task); + /// + public override void WasCancelled(global::Speech.SFSpeechRecognitionTask task) => _wasCancelled.OnNext(task); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SFSpeechRecognizerDelegateRx : global::Speech.SFSpeechRecognizerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognizer speechRecognizer, bool available)> _availabilityDidChange = new Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognizer speechRecognizer, bool available)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Speech.SFSpeechRecognizer speechRecognizer, bool available)> AvailabilityDidChangeObs => _availabilityDidChange; + /// + public override void AvailabilityDidChange(global::Speech.SFSpeechRecognizer speechRecognizer, bool available) => _availabilityDidChange.OnNext((speechRecognizer, available)); + } +} + +namespace SpriteKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class SKPhysicsContactDelegateRx : global::SpriteKit.SKPhysicsContactDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBeginContact = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEndContact = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBeginContactObs => _didBeginContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndContactObs => _didEndContact; + /// + public override void DidBeginContact(global::SpriteKit.SKPhysicsContact contact) => _didBeginContact.OnNext(contact); + /// + public override void DidEndContact(global::SpriteKit.SKPhysicsContact contact) => _didEndContact.OnNext(contact); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SKSceneDelegateRx : global::SpriteKit.SKSceneDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didApplyConstraints = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEvaluateActions = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinishUpdate = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didSimulatePhysics = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(double currentTime, global::SpriteKit.SKScene scene)> _update = new Pharmacist.Common.SingleAwaitSubject<(double currentTime, global::SpriteKit.SKScene scene)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidApplyConstraintsObs => _didApplyConstraints; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEvaluateActionsObs => _didEvaluateActions; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishUpdateObs => _didFinishUpdate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidSimulatePhysicsObs => _didSimulatePhysics; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(double currentTime, global::SpriteKit.SKScene scene)> UpdateObs => _update; + /// + public override void DidApplyConstraints(global::SpriteKit.SKScene scene) => _didApplyConstraints.OnNext(scene); + /// + public override void DidEvaluateActions(global::SpriteKit.SKScene scene) => _didEvaluateActions.OnNext(scene); + /// + public override void DidFinishUpdate(global::SpriteKit.SKScene scene) => _didFinishUpdate.OnNext(scene); + /// + public override void DidSimulatePhysics(global::SpriteKit.SKScene scene) => _didSimulatePhysics.OnNext(scene); + /// + public override void Update(double currentTime, global::SpriteKit.SKScene scene) => _update.OnNext((currentTime, scene)); + } +} + +namespace StoreKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class SKCloudServiceSetupViewControllerDelegateRx : global::StoreKit.SKCloudServiceSetupViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didDismiss = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDismissObs => _didDismiss; + /// + public override void DidDismiss(global::StoreKit.SKCloudServiceSetupViewController cloudServiceSetupViewController) => _didDismiss.OnNext(cloudServiceSetupViewController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SKOverlayDelegateRx : global::StoreKit.SKOverlayDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKOverlay overlay, global::Foundation.NSError error)> _didFailToLoad = new Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKOverlay overlay, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext)> _didFinishDismissal = new Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext)> _didFinishPresentation = new Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext)> _willStartDismissal = new Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext)> _willStartPresentation = new Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::StoreKit.SKOverlay overlay, global::Foundation.NSError error)> DidFailToLoadObs => _didFailToLoad; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext)> DidFinishDismissalObs => _didFinishDismissal; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext)> DidFinishPresentationObs => _didFinishPresentation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext)> WillStartDismissalObs => _willStartDismissal; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext)> WillStartPresentationObs => _willStartPresentation; + /// + public override void DidFailToLoad(global::StoreKit.SKOverlay overlay, global::Foundation.NSError error) => _didFailToLoad.OnNext((overlay, error)); + /// + public override void DidFinishDismissal(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext) => _didFinishDismissal.OnNext((overlay, transitionContext)); + /// + public override void DidFinishPresentation(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext) => _didFinishPresentation.OnNext((overlay, transitionContext)); + /// + public override void WillStartDismissal(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext) => _willStartDismissal.OnNext((overlay, transitionContext)); + /// + public override void WillStartPresentation(global::StoreKit.SKOverlay overlay, global::StoreKit.SKOverlayTransitionContext transitionContext) => _willStartPresentation.OnNext((overlay, transitionContext)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class SKProductsRequestDelegateRx : global::StoreKit.SKProductsRequestDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKProductsRequest request, global::StoreKit.SKProductsResponse response)> _receivedResponse = new Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKProductsRequest request, global::StoreKit.SKProductsResponse response)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::StoreKit.SKProductsRequest request, global::StoreKit.SKProductsResponse response)> ReceivedResponseObs => _receivedResponse; + /// + public override void ReceivedResponse(global::StoreKit.SKProductsRequest request, global::StoreKit.SKProductsResponse response) => _receivedResponse.OnNext((request, response)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SKRequestDelegateRx : global::StoreKit.SKRequestDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKRequest request, global::Foundation.NSError error)> _requestFailed = new Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKRequest request, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _requestFinished = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::StoreKit.SKRequest request, global::Foundation.NSError error)> RequestFailedObs => _requestFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable RequestFinishedObs => _requestFinished; + /// + public override void RequestFailed(global::StoreKit.SKRequest request, global::Foundation.NSError error) => _requestFailed.OnNext((request, error)); + /// + public override void RequestFinished(global::StoreKit.SKRequest request) => _requestFinished.OnNext(request); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SKStoreProductViewControllerDelegateRx : global::StoreKit.SKStoreProductViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _finished = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedObs => _finished; + /// + public override void Finished(global::StoreKit.SKStoreProductViewController controller) => _finished.OnNext(controller); + } +} + +namespace UIKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSLayoutManagerDelegateRx : global::UIKit.NSLayoutManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.NSLayoutManager layoutManager, global::UIKit.NSTextContainer textContainer, global::CoreGraphics.CGSize oldSize)> _didChangeGeometry = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.NSLayoutManager layoutManager, global::UIKit.NSTextContainer textContainer, global::CoreGraphics.CGSize oldSize)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.NSLayoutManager layoutManager, global::UIKit.NSTextContainer textContainer, bool layoutFinishedFlag)> _didCompleteLayout = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.NSLayoutManager layoutManager, global::UIKit.NSTextContainer textContainer, bool layoutFinishedFlag)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didInvalidatedLayout = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.NSLayoutManager layoutManager, global::UIKit.NSTextContainer textContainer, global::CoreGraphics.CGSize oldSize)> DidChangeGeometryObs => _didChangeGeometry; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.NSLayoutManager layoutManager, global::UIKit.NSTextContainer textContainer, bool layoutFinishedFlag)> DidCompleteLayoutObs => _didCompleteLayout; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidInvalidatedLayoutObs => _didInvalidatedLayout; + /// + public override void DidChangeGeometry(global::UIKit.NSLayoutManager layoutManager, global::UIKit.NSTextContainer textContainer, global::CoreGraphics.CGSize oldSize) => _didChangeGeometry.OnNext((layoutManager, textContainer, oldSize)); + /// + public override void DidCompleteLayout(global::UIKit.NSLayoutManager layoutManager, global::UIKit.NSTextContainer textContainer, bool layoutFinishedFlag) => _didCompleteLayout.OnNext((layoutManager, textContainer, layoutFinishedFlag)); + /// + public override void DidInvalidatedLayout(global::UIKit.NSLayoutManager sender) => _didInvalidatedLayout.OnNext(sender); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSTextStorageDelegateRx : global::UIKit.NSTextStorageDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.NSTextStorage textStorage, global::UIKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta)> _didProcessEditing = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.NSTextStorage textStorage, global::UIKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.NSTextStorage textStorage, global::UIKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta)> _willProcessEditing = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.NSTextStorage textStorage, global::UIKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.NSTextStorage textStorage, global::UIKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta)> DidProcessEditingObs => _didProcessEditing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.NSTextStorage textStorage, global::UIKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta)> WillProcessEditingObs => _willProcessEditing; + /// + public override void DidProcessEditing(global::UIKit.NSTextStorage textStorage, global::UIKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta) => _didProcessEditing.OnNext((textStorage, editedMask, editedRange, delta)); + /// + public override void WillProcessEditing(global::UIKit.NSTextStorage textStorage, global::UIKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta) => _willProcessEditing.OnNext((textStorage, editedMask, editedRange, delta)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIAccelerometerDelegateRx : global::UIKit.UIAccelerometerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIAccelerometer accelerometer, global::UIKit.UIAcceleration acceleration)> _didAccelerate = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIAccelerometer accelerometer, global::UIKit.UIAcceleration acceleration)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIAccelerometer accelerometer, global::UIKit.UIAcceleration acceleration)> DidAccelerateObs => _didAccelerate; + /// + public override void DidAccelerate(global::UIKit.UIAccelerometer accelerometer, global::UIKit.UIAcceleration acceleration) => _didAccelerate.OnNext((accelerometer, acceleration)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIActionSheetDelegateRx : global::UIKit.UIActionSheetDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _canceled = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIActionSheet actionSheet, global::System.nint buttonIndex)> _clicked = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIActionSheet actionSheet, global::System.nint buttonIndex)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIActionSheet actionSheet, global::System.nint buttonIndex)> _dismissed = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIActionSheet actionSheet, global::System.nint buttonIndex)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _presented = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIActionSheet actionSheet, global::System.nint buttonIndex)> _willDismiss = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIActionSheet actionSheet, global::System.nint buttonIndex)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willPresent = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable CanceledObs => _canceled; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIActionSheet actionSheet, global::System.nint buttonIndex)> ClickedObs => _clicked; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIActionSheet actionSheet, global::System.nint buttonIndex)> DismissedObs => _dismissed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PresentedObs => _presented; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIActionSheet actionSheet, global::System.nint buttonIndex)> WillDismissObs => _willDismiss; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillPresentObs => _willPresent; + /// + public override void Canceled(global::UIKit.UIActionSheet actionSheet) => _canceled.OnNext(actionSheet); + /// + public override void Clicked(global::UIKit.UIActionSheet actionSheet, global::System.nint buttonIndex) => _clicked.OnNext((actionSheet, buttonIndex)); + /// + public override void Dismissed(global::UIKit.UIActionSheet actionSheet, global::System.nint buttonIndex) => _dismissed.OnNext((actionSheet, buttonIndex)); + /// + public override void Presented(global::UIKit.UIActionSheet actionSheet) => _presented.OnNext(actionSheet); + /// + public override void WillDismiss(global::UIKit.UIActionSheet actionSheet, global::System.nint buttonIndex) => _willDismiss.OnNext((actionSheet, buttonIndex)); + /// + public override void WillPresent(global::UIKit.UIActionSheet actionSheet) => _willPresent.OnNext(actionSheet); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIAdaptivePresentationControllerDelegateRx : global::UIKit.UIAdaptivePresentationControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didAttemptToDismiss = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didDismiss = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willDismiss = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPresentationController presentationController, global::UIKit.UIModalPresentationStyle style, global::UIKit.IUIViewControllerTransitionCoordinator transitionCoordinator)> _willPresent = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPresentationController presentationController, global::UIKit.UIModalPresentationStyle style, global::UIKit.IUIViewControllerTransitionCoordinator transitionCoordinator)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidAttemptToDismissObs => _didAttemptToDismiss; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDismissObs => _didDismiss; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillDismissObs => _willDismiss; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIPresentationController presentationController, global::UIKit.UIModalPresentationStyle style, global::UIKit.IUIViewControllerTransitionCoordinator transitionCoordinator)> WillPresentObs => _willPresent; + /// + public override void DidAttemptToDismiss(global::UIKit.UIPresentationController presentationController) => _didAttemptToDismiss.OnNext(presentationController); + /// + public override void DidDismiss(global::UIKit.UIPresentationController presentationController) => _didDismiss.OnNext(presentationController); + /// + public override void WillDismiss(global::UIKit.UIPresentationController presentationController) => _willDismiss.OnNext(presentationController); + /// + public override void WillPresent(global::UIKit.UIPresentationController presentationController, global::UIKit.UIModalPresentationStyle style, global::UIKit.IUIViewControllerTransitionCoordinator transitionCoordinator) => _willPresent.OnNext((presentationController, style, transitionCoordinator)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIAlertViewDelegateRx : global::UIKit.UIAlertViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _canceled = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIAlertView alertview, global::System.nint buttonIndex)> _clicked = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIAlertView alertview, global::System.nint buttonIndex)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIAlertView alertView, global::System.nint buttonIndex)> _dismissed = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIAlertView alertView, global::System.nint buttonIndex)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _presented = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIAlertView alertView, global::System.nint buttonIndex)> _willDismiss = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIAlertView alertView, global::System.nint buttonIndex)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willPresent = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable CanceledObs => _canceled; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIAlertView alertview, global::System.nint buttonIndex)> ClickedObs => _clicked; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIAlertView alertView, global::System.nint buttonIndex)> DismissedObs => _dismissed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PresentedObs => _presented; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIAlertView alertView, global::System.nint buttonIndex)> WillDismissObs => _willDismiss; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillPresentObs => _willPresent; + /// + public override void Canceled(global::UIKit.UIAlertView alertView) => _canceled.OnNext(alertView); + /// + public override void Clicked(global::UIKit.UIAlertView alertview, global::System.nint buttonIndex) => _clicked.OnNext((alertview, buttonIndex)); + /// + public override void Dismissed(global::UIKit.UIAlertView alertView, global::System.nint buttonIndex) => _dismissed.OnNext((alertView, buttonIndex)); + /// + public override void Presented(global::UIKit.UIAlertView alertView) => _presented.OnNext(alertView); + /// + public override void WillDismiss(global::UIKit.UIAlertView alertView, global::System.nint buttonIndex) => _willDismiss.OnNext((alertView, buttonIndex)); + /// + public override void WillPresent(global::UIKit.UIAlertView alertView) => _willPresent.OnNext(alertView); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIApplicationDelegateRx : global::UIKit.UIApplicationDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _applicationSignificantTimeChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CoreGraphics.CGRect oldStatusBarFrame)> _changedStatusBarFrame = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CoreGraphics.CGRect oldStatusBarFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation oldStatusBarOrientation)> _didChangeStatusBarOrientation = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation oldStatusBarOrientation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSCoder coder)> _didDecodeRestorableState = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSCoder coder)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSSet sceneSessions)> _didDiscardSceneSessions = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSSet sceneSessions)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEnterBackground = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, string userActivityType, global::Foundation.NSError error)> _didFailToContinueUserActivitiy = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, string userActivityType, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action completionHandler)> _didReceiveRemoteNotification = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIUserNotificationSettings notificationSettings)> _didRegisterUserNotificationSettings = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIUserNotificationSettings notificationSettings)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSError error)> _failedToRegisterForRemoteNotifications = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _finishedLaunching = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, string actionIdentifier, global::UIKit.UILocalNotification localNotification, global::Foundation.NSDictionary responseInfo, global::System.Action completionHandler)> _handleAction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, string actionIdentifier, global::UIKit.UILocalNotification localNotification, global::Foundation.NSDictionary responseInfo, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, string sessionIdentifier, global::System.Action completionHandler)> _handleEventsForBackgroundUrl = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, string sessionIdentifier, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Intents.INIntent intent, global::System.Action completionHandler)> _handleIntent = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Intents.INIntent intent, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action reply)> _handleWatchKitExtensionRequest = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action reply)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _onActivated = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _onResignActivation = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIApplicationShortcutItem shortcutItem, global::UIKit.UIOperationHandler completionHandler)> _performActionForShortcutItem = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIApplicationShortcutItem shortcutItem, global::UIKit.UIOperationHandler completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::System.Action completionHandler)> _performFetch = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _protectedDataDidBecomeAvailable = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _protectedDataWillBecomeUnavailable = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UILocalNotification notification)> _receivedLocalNotification = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UILocalNotification notification)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo)> _receivedRemoteNotification = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _receiveMemoryWarning = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSData deviceToken)> _registeredForRemoteNotifications = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSData deviceToken)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _shouldRequestHealthAuthorization = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSUserActivity userActivity)> _userActivityUpdated = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSUserActivity userActivity)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CloudKit.CKShareMetadata cloudKitShareMetadata)> _userDidAcceptCloudKitShare = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CloudKit.CKShareMetadata cloudKitShareMetadata)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CoreGraphics.CGRect newStatusBarFrame)> _willChangeStatusBarFrame = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::CoreGraphics.CGRect newStatusBarFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation newStatusBarOrientation, double duration)> _willChangeStatusBarOrientation = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation newStatusBarOrientation, double duration)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSCoder coder)> _willEncodeRestorableState = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIApplication application, global::Foundation.NSCoder coder)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willEnterForeground = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willTerminate = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ApplicationSignificantTimeChangeObs => _applicationSignificantTimeChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::CoreGraphics.CGRect oldStatusBarFrame)> ChangedStatusBarFrameObs => _changedStatusBarFrame; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation oldStatusBarOrientation)> DidChangeStatusBarOrientationObs => _didChangeStatusBarOrientation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSCoder coder)> DidDecodeRestorableStateObs => _didDecodeRestorableState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSSet sceneSessions)> DidDiscardSceneSessionsObs => _didDiscardSceneSessions; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEnterBackgroundObs => _didEnterBackground; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, string userActivityType, global::Foundation.NSError error)> DidFailToContinueUserActivitiyObs => _didFailToContinueUserActivitiy; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action completionHandler)> DidReceiveRemoteNotificationObs => _didReceiveRemoteNotification; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::UIKit.UIUserNotificationSettings notificationSettings)> DidRegisterUserNotificationSettingsObs => _didRegisterUserNotificationSettings; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSError error)> FailedToRegisterForRemoteNotificationsObs => _failedToRegisterForRemoteNotifications; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedLaunchingObs => _finishedLaunching; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, string actionIdentifier, global::UIKit.UILocalNotification localNotification, global::Foundation.NSDictionary responseInfo, global::System.Action completionHandler)> HandleActionObs => _handleAction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, string sessionIdentifier, global::System.Action completionHandler)> HandleEventsForBackgroundUrlObs => _handleEventsForBackgroundUrl; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Intents.INIntent intent, global::System.Action completionHandler)> HandleIntentObs => _handleIntent; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action reply)> HandleWatchKitExtensionRequestObs => _handleWatchKitExtensionRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OnActivatedObs => _onActivated; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OnResignActivationObs => _onResignActivation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::UIKit.UIApplicationShortcutItem shortcutItem, global::UIKit.UIOperationHandler completionHandler)> PerformActionForShortcutItemObs => _performActionForShortcutItem; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::System.Action completionHandler)> PerformFetchObs => _performFetch; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ProtectedDataDidBecomeAvailableObs => _protectedDataDidBecomeAvailable; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ProtectedDataWillBecomeUnavailableObs => _protectedDataWillBecomeUnavailable; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::UIKit.UILocalNotification notification)> ReceivedLocalNotificationObs => _receivedLocalNotification; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo)> ReceivedRemoteNotificationObs => _receivedRemoteNotification; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ReceiveMemoryWarningObs => _receiveMemoryWarning; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSData deviceToken)> RegisteredForRemoteNotificationsObs => _registeredForRemoteNotifications; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ShouldRequestHealthAuthorizationObs => _shouldRequestHealthAuthorization; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSUserActivity userActivity)> UserActivityUpdatedObs => _userActivityUpdated; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::CloudKit.CKShareMetadata cloudKitShareMetadata)> UserDidAcceptCloudKitShareObs => _userDidAcceptCloudKitShare; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::CoreGraphics.CGRect newStatusBarFrame)> WillChangeStatusBarFrameObs => _willChangeStatusBarFrame; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation newStatusBarOrientation, double duration)> WillChangeStatusBarOrientationObs => _willChangeStatusBarOrientation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIApplication application, global::Foundation.NSCoder coder)> WillEncodeRestorableStateObs => _willEncodeRestorableState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillEnterForegroundObs => _willEnterForeground; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillTerminateObs => _willTerminate; + /// + public override void ApplicationSignificantTimeChange(global::UIKit.UIApplication application) => _applicationSignificantTimeChange.OnNext(application); + /// + public override void ChangedStatusBarFrame(global::UIKit.UIApplication application, global::CoreGraphics.CGRect oldStatusBarFrame) => _changedStatusBarFrame.OnNext((application, oldStatusBarFrame)); + /// + public override void DidChangeStatusBarOrientation(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation oldStatusBarOrientation) => _didChangeStatusBarOrientation.OnNext((application, oldStatusBarOrientation)); + /// + public override void DidDecodeRestorableState(global::UIKit.UIApplication application, global::Foundation.NSCoder coder) => _didDecodeRestorableState.OnNext((application, coder)); + /// + public override void DidDiscardSceneSessions(global::UIKit.UIApplication application, global::Foundation.NSSet sceneSessions) => _didDiscardSceneSessions.OnNext((application, sceneSessions)); + /// + public override void DidEnterBackground(global::UIKit.UIApplication application) => _didEnterBackground.OnNext(application); + /// + public override void DidFailToContinueUserActivitiy(global::UIKit.UIApplication application, string userActivityType, global::Foundation.NSError error) => _didFailToContinueUserActivitiy.OnNext((application, userActivityType, error)); + /// + public override void DidReceiveRemoteNotification(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action completionHandler) => _didReceiveRemoteNotification.OnNext((application, userInfo, completionHandler)); + /// + public override void DidRegisterUserNotificationSettings(global::UIKit.UIApplication application, global::UIKit.UIUserNotificationSettings notificationSettings) => _didRegisterUserNotificationSettings.OnNext((application, notificationSettings)); + /// + public override void FailedToRegisterForRemoteNotifications(global::UIKit.UIApplication application, global::Foundation.NSError error) => _failedToRegisterForRemoteNotifications.OnNext((application, error)); + /// + public override void FinishedLaunching(global::UIKit.UIApplication application) => _finishedLaunching.OnNext(application); + /// + public override void HandleAction(global::UIKit.UIApplication application, string actionIdentifier, global::UIKit.UILocalNotification localNotification, global::Foundation.NSDictionary responseInfo, global::System.Action completionHandler) => _handleAction.OnNext((application, actionIdentifier, localNotification, responseInfo, completionHandler)); + /// + public override void HandleEventsForBackgroundUrl(global::UIKit.UIApplication application, string sessionIdentifier, global::System.Action completionHandler) => _handleEventsForBackgroundUrl.OnNext((application, sessionIdentifier, completionHandler)); + /// + public override void HandleIntent(global::UIKit.UIApplication application, global::Intents.INIntent intent, global::System.Action completionHandler) => _handleIntent.OnNext((application, intent, completionHandler)); + /// + public override void HandleWatchKitExtensionRequest(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo, global::System.Action reply) => _handleWatchKitExtensionRequest.OnNext((application, userInfo, reply)); + /// + public override void OnActivated(global::UIKit.UIApplication application) => _onActivated.OnNext(application); + /// + public override void OnResignActivation(global::UIKit.UIApplication application) => _onResignActivation.OnNext(application); + /// + public override void PerformActionForShortcutItem(global::UIKit.UIApplication application, global::UIKit.UIApplicationShortcutItem shortcutItem, global::UIKit.UIOperationHandler completionHandler) => _performActionForShortcutItem.OnNext((application, shortcutItem, completionHandler)); + /// + public override void PerformFetch(global::UIKit.UIApplication application, global::System.Action completionHandler) => _performFetch.OnNext((application, completionHandler)); + /// + public override void ProtectedDataDidBecomeAvailable(global::UIKit.UIApplication application) => _protectedDataDidBecomeAvailable.OnNext(application); + /// + public override void ProtectedDataWillBecomeUnavailable(global::UIKit.UIApplication application) => _protectedDataWillBecomeUnavailable.OnNext(application); + /// + public override void ReceivedLocalNotification(global::UIKit.UIApplication application, global::UIKit.UILocalNotification notification) => _receivedLocalNotification.OnNext((application, notification)); + /// + public override void ReceivedRemoteNotification(global::UIKit.UIApplication application, global::Foundation.NSDictionary userInfo) => _receivedRemoteNotification.OnNext((application, userInfo)); + /// + public override void ReceiveMemoryWarning(global::UIKit.UIApplication application) => _receiveMemoryWarning.OnNext(application); + /// + public override void RegisteredForRemoteNotifications(global::UIKit.UIApplication application, global::Foundation.NSData deviceToken) => _registeredForRemoteNotifications.OnNext((application, deviceToken)); + /// + public override void ShouldRequestHealthAuthorization(global::UIKit.UIApplication application) => _shouldRequestHealthAuthorization.OnNext(application); + /// + public override void UserActivityUpdated(global::UIKit.UIApplication application, global::Foundation.NSUserActivity userActivity) => _userActivityUpdated.OnNext((application, userActivity)); + /// + public override void UserDidAcceptCloudKitShare(global::UIKit.UIApplication application, global::CloudKit.CKShareMetadata cloudKitShareMetadata) => _userDidAcceptCloudKitShare.OnNext((application, cloudKitShareMetadata)); + /// + public override void WillChangeStatusBarFrame(global::UIKit.UIApplication application, global::CoreGraphics.CGRect newStatusBarFrame) => _willChangeStatusBarFrame.OnNext((application, newStatusBarFrame)); + /// + public override void WillChangeStatusBarOrientation(global::UIKit.UIApplication application, global::UIKit.UIInterfaceOrientation newStatusBarOrientation, double duration) => _willChangeStatusBarOrientation.OnNext((application, newStatusBarOrientation, duration)); + /// + public override void WillEncodeRestorableState(global::UIKit.UIApplication application, global::Foundation.NSCoder coder) => _willEncodeRestorableState.OnNext((application, coder)); + /// + public override void WillEnterForeground(global::UIKit.UIApplication application) => _willEnterForeground.OnNext(application); + /// + public override void WillTerminate(global::UIKit.UIApplication application) => _willTerminate.OnNext(application); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UICloudSharingControllerDelegateRx : global::UIKit.UICloudSharingControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didSaveShare = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didStopSharing = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICloudSharingController csc, global::Foundation.NSError error)> _failedToSaveShare = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICloudSharingController csc, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidSaveShareObs => _didSaveShare; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidStopSharingObs => _didStopSharing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICloudSharingController csc, global::Foundation.NSError error)> FailedToSaveShareObs => _failedToSaveShare; + /// + public override void DidSaveShare(global::UIKit.UICloudSharingController csc) => _didSaveShare.OnNext(csc); + /// + public override void DidStopSharing(global::UIKit.UICloudSharingController csc) => _didStopSharing.OnNext(csc); + /// + public override void FailedToSaveShare(global::UIKit.UICloudSharingController csc, global::Foundation.NSError error) => _failedToSaveShare.OnNext((csc, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UICollectionViewDelegateRx : global::UIKit.UICollectionViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionViewCell cell, global::Foundation.NSIndexPath indexPath)> _cellDisplayingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionViewCell cell, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _decelerationEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _decelerationStarted = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath)> _didBeginMultipleSelectionInteraction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeAdjustedContentInset = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEndMultipleSelectionInteraction = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionViewFocusUpdateContext context, global::UIKit.UIFocusAnimationCoordinator coordinator)> _didUpdateFocus = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionViewFocusUpdateContext context, global::UIKit.UIFocusAnimationCoordinator coordinator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didZoom = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, bool willDecelerate)> _draggingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, bool willDecelerate)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _draggingStarted = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath)> _itemDeselected = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath)> _itemHighlighted = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath)> _itemSelected = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath)> _itemUnhighlighted = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::ObjCRuntime.Selector action, global::Foundation.NSIndexPath indexPath, global::Foundation.NSObject sender)> _performAction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::ObjCRuntime.Selector action, global::Foundation.NSIndexPath indexPath, global::Foundation.NSObject sender)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _scrollAnimationEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _scrolled = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _scrolledToTop = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionReusableView view, global::Foundation.NSString elementKind, global::Foundation.NSIndexPath indexPath)> _supplementaryViewDisplayingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionReusableView view, global::Foundation.NSString elementKind, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionViewCell cell, global::Foundation.NSIndexPath indexPath)> _willDisplayCell = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionViewCell cell, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> _willDisplayContextMenu = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionReusableView view, string elementKind, global::Foundation.NSIndexPath indexPath)> _willDisplaySupplementaryView = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionReusableView view, string elementKind, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> _willEndContextMenuInteraction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator)> _willPerformPreviewAction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView withView, global::System.nfloat atScale)> _zoomingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView withView, global::System.nfloat atScale)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView view)> _zoomingStarted = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView view)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionViewCell cell, global::Foundation.NSIndexPath indexPath)> CellDisplayingEndedObs => _cellDisplayingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DecelerationEndedObs => _decelerationEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DecelerationStartedObs => _decelerationStarted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath)> DidBeginMultipleSelectionInteractionObs => _didBeginMultipleSelectionInteraction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeAdjustedContentInsetObs => _didChangeAdjustedContentInset; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndMultipleSelectionInteractionObs => _didEndMultipleSelectionInteraction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionViewFocusUpdateContext context, global::UIKit.UIFocusAnimationCoordinator coordinator)> DidUpdateFocusObs => _didUpdateFocus; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidZoomObs => _didZoom; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScrollView scrollView, bool willDecelerate)> DraggingEndedObs => _draggingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DraggingStartedObs => _draggingStarted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath)> ItemDeselectedObs => _itemDeselected; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath)> ItemHighlightedObs => _itemHighlighted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath)> ItemSelectedObs => _itemSelected; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath)> ItemUnhighlightedObs => _itemUnhighlighted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::ObjCRuntime.Selector action, global::Foundation.NSIndexPath indexPath, global::Foundation.NSObject sender)> PerformActionObs => _performAction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ScrollAnimationEndedObs => _scrollAnimationEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ScrolledObs => _scrolled; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ScrolledToTopObs => _scrolledToTop; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionReusableView view, global::Foundation.NSString elementKind, global::Foundation.NSIndexPath indexPath)> SupplementaryViewDisplayingEndedObs => _supplementaryViewDisplayingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionViewCell cell, global::Foundation.NSIndexPath indexPath)> WillDisplayCellObs => _willDisplayCell; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> WillDisplayContextMenuObs => _willDisplayContextMenu; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionReusableView view, string elementKind, global::Foundation.NSIndexPath indexPath)> WillDisplaySupplementaryViewObs => _willDisplaySupplementaryView; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> WillEndContextMenuInteractionObs => _willEndContextMenuInteraction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator)> WillPerformPreviewActionObs => _willPerformPreviewAction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView withView, global::System.nfloat atScale)> ZoomingEndedObs => _zoomingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView view)> ZoomingStartedObs => _zoomingStarted; + /// + public override void CellDisplayingEnded(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionViewCell cell, global::Foundation.NSIndexPath indexPath) => _cellDisplayingEnded.OnNext((collectionView, cell, indexPath)); + /// + public override void DecelerationEnded(global::UIKit.UIScrollView scrollView) => _decelerationEnded.OnNext(scrollView); + /// + public override void DecelerationStarted(global::UIKit.UIScrollView scrollView) => _decelerationStarted.OnNext(scrollView); + /// + public override void DidBeginMultipleSelectionInteraction(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath) => _didBeginMultipleSelectionInteraction.OnNext((collectionView, indexPath)); + /// + public override void DidChangeAdjustedContentInset(global::UIKit.UIScrollView scrollView) => _didChangeAdjustedContentInset.OnNext(scrollView); + /// + public override void DidEndMultipleSelectionInteraction(global::UIKit.UICollectionView collectionView) => _didEndMultipleSelectionInteraction.OnNext(collectionView); + /// + public override void DidUpdateFocus(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionViewFocusUpdateContext context, global::UIKit.UIFocusAnimationCoordinator coordinator) => _didUpdateFocus.OnNext((collectionView, context, coordinator)); + /// + public override void DidZoom(global::UIKit.UIScrollView scrollView) => _didZoom.OnNext(scrollView); + /// + public override void DraggingEnded(global::UIKit.UIScrollView scrollView, bool willDecelerate) => _draggingEnded.OnNext((scrollView, willDecelerate)); + /// + public override void DraggingStarted(global::UIKit.UIScrollView scrollView) => _draggingStarted.OnNext(scrollView); + /// + public override void ItemDeselected(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath) => _itemDeselected.OnNext((collectionView, indexPath)); + /// + public override void ItemHighlighted(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath) => _itemHighlighted.OnNext((collectionView, indexPath)); + /// + public override void ItemSelected(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath) => _itemSelected.OnNext((collectionView, indexPath)); + /// + public override void ItemUnhighlighted(global::UIKit.UICollectionView collectionView, global::Foundation.NSIndexPath indexPath) => _itemUnhighlighted.OnNext((collectionView, indexPath)); + /// + public override void PerformAction(global::UIKit.UICollectionView collectionView, global::ObjCRuntime.Selector action, global::Foundation.NSIndexPath indexPath, global::Foundation.NSObject sender) => _performAction.OnNext((collectionView, action, indexPath, sender)); + /// + public override void ScrollAnimationEnded(global::UIKit.UIScrollView scrollView) => _scrollAnimationEnded.OnNext(scrollView); + /// + public override void Scrolled(global::UIKit.UIScrollView scrollView) => _scrolled.OnNext(scrollView); + /// + public override void ScrolledToTop(global::UIKit.UIScrollView scrollView) => _scrolledToTop.OnNext(scrollView); + /// + public override void SupplementaryViewDisplayingEnded(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionReusableView view, global::Foundation.NSString elementKind, global::Foundation.NSIndexPath indexPath) => _supplementaryViewDisplayingEnded.OnNext((collectionView, view, elementKind, indexPath)); + /// + public override void WillDisplayCell(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionViewCell cell, global::Foundation.NSIndexPath indexPath) => _willDisplayCell.OnNext((collectionView, cell, indexPath)); + /// + public override void WillDisplayContextMenu(global::UIKit.UICollectionView collectionView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator) => _willDisplayContextMenu.OnNext((collectionView, configuration, animator)); + /// + public override void WillDisplaySupplementaryView(global::UIKit.UICollectionView collectionView, global::UIKit.UICollectionReusableView view, string elementKind, global::Foundation.NSIndexPath indexPath) => _willDisplaySupplementaryView.OnNext((collectionView, view, elementKind, indexPath)); + /// + public override void WillEndContextMenuInteraction(global::UIKit.UICollectionView collectionView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator) => _willEndContextMenuInteraction.OnNext((collectionView, configuration, animator)); + /// + public override void WillPerformPreviewAction(global::UIKit.UICollectionView collectionView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator) => _willPerformPreviewAction.OnNext((collectionView, configuration, animator)); + /// + public override void ZoomingEnded(global::UIKit.UIScrollView scrollView, global::UIKit.UIView withView, global::System.nfloat atScale) => _zoomingEnded.OnNext((scrollView, withView, atScale)); + /// + public override void ZoomingStarted(global::UIKit.UIScrollView scrollView, global::UIKit.UIView view) => _zoomingStarted.OnNext((scrollView, view)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UICollectionViewDragDelegateRx : global::UIKit.UICollectionViewDragDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDragSession session)> _dragSessionDidEnd = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDragSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDragSession session)> _dragSessionWillBegin = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDragSession session)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDragSession session)> DragSessionDidEndObs => _dragSessionDidEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDragSession session)> DragSessionWillBeginObs => _dragSessionWillBegin; + /// + public override void DragSessionDidEnd(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDragSession session) => _dragSessionDidEnd.OnNext((collectionView, session)); + /// + public override void DragSessionWillBegin(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDragSession session) => _dragSessionWillBegin.OnNext((collectionView, session)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UICollectionViewDropDelegateRx : global::UIKit.UICollectionViewDropDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDropSession session)> _dropSessionDidEnd = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDropSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDropSession session)> _dropSessionDidEnter = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDropSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDropSession session)> _dropSessionDidExit = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDropSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.IUICollectionViewDropCoordinator coordinator)> _performDrop = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollectionView collectionView, global::UIKit.IUICollectionViewDropCoordinator coordinator)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDropSession session)> DropSessionDidEndObs => _dropSessionDidEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDropSession session)> DropSessionDidEnterObs => _dropSessionDidEnter; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDropSession session)> DropSessionDidExitObs => _dropSessionDidExit; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollectionView collectionView, global::UIKit.IUICollectionViewDropCoordinator coordinator)> PerformDropObs => _performDrop; + /// + public override void DropSessionDidEnd(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDropSession session) => _dropSessionDidEnd.OnNext((collectionView, session)); + /// + public override void DropSessionDidEnter(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDropSession session) => _dropSessionDidEnter.OnNext((collectionView, session)); + /// + public override void DropSessionDidExit(global::UIKit.UICollectionView collectionView, global::UIKit.IUIDropSession session) => _dropSessionDidExit.OnNext((collectionView, session)); + /// + public override void PerformDrop(global::UIKit.UICollectionView collectionView, global::UIKit.IUICollectionViewDropCoordinator coordinator) => _performDrop.OnNext((collectionView, coordinator)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UICollisionBehaviorDelegateRx : global::UIKit.UICollisionBehaviorDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem dynamicItem, global::Foundation.NSObject boundaryIdentifier, global::CoreGraphics.CGPoint atPoint)> _beganBoundaryContact = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem dynamicItem, global::Foundation.NSObject boundaryIdentifier, global::CoreGraphics.CGPoint atPoint)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem firstItem, global::UIKit.IUIDynamicItem secondItem, global::CoreGraphics.CGPoint atPoint)> _beganContact = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem firstItem, global::UIKit.IUIDynamicItem secondItem, global::CoreGraphics.CGPoint atPoint)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem dynamicItem, global::Foundation.NSObject boundaryIdentifier)> _endedBoundaryContact = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem dynamicItem, global::Foundation.NSObject boundaryIdentifier)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem firstItem, global::UIKit.IUIDynamicItem secondItem)> _endedContact = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem firstItem, global::UIKit.IUIDynamicItem secondItem)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem dynamicItem, global::Foundation.NSObject boundaryIdentifier, global::CoreGraphics.CGPoint atPoint)> BeganBoundaryContactObs => _beganBoundaryContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem firstItem, global::UIKit.IUIDynamicItem secondItem, global::CoreGraphics.CGPoint atPoint)> BeganContactObs => _beganContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem dynamicItem, global::Foundation.NSObject boundaryIdentifier)> EndedBoundaryContactObs => _endedBoundaryContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem firstItem, global::UIKit.IUIDynamicItem secondItem)> EndedContactObs => _endedContact; + /// + public override void BeganBoundaryContact(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem dynamicItem, global::Foundation.NSObject boundaryIdentifier, global::CoreGraphics.CGPoint atPoint) => _beganBoundaryContact.OnNext((behavior, dynamicItem, boundaryIdentifier, atPoint)); + /// + public override void BeganContact(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem firstItem, global::UIKit.IUIDynamicItem secondItem, global::CoreGraphics.CGPoint atPoint) => _beganContact.OnNext((behavior, firstItem, secondItem, atPoint)); + /// + public override void EndedBoundaryContact(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem dynamicItem, global::Foundation.NSObject boundaryIdentifier) => _endedBoundaryContact.OnNext((behavior, dynamicItem, boundaryIdentifier)); + /// + public override void EndedContact(global::UIKit.UICollisionBehavior behavior, global::UIKit.IUIDynamicItem firstItem, global::UIKit.IUIDynamicItem secondItem) => _endedContact.OnNext((behavior, firstItem, secondItem)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIColorPickerViewControllerDelegateRx : global::UIKit.UIColorPickerViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didFinish = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didSelectColor = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishObs => _didFinish; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidSelectColorObs => _didSelectColor; + /// + public override void DidFinish(global::UIKit.UIColorPickerViewController viewController) => _didFinish.OnNext(viewController); + /// + public override void DidSelectColor(global::UIKit.UIColorPickerViewController viewController) => _didSelectColor.OnNext(viewController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UIContextMenuInteractionDelegateRx : global::UIKit.UIContextMenuInteractionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIContextMenuInteraction interaction, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> _willDisplayMenu = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIContextMenuInteraction interaction, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIContextMenuInteraction interaction, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> _willEnd = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIContextMenuInteraction interaction, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIContextMenuInteraction interaction, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator)> _willPerformPreviewAction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIContextMenuInteraction interaction, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIContextMenuInteraction interaction, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> WillDisplayMenuObs => _willDisplayMenu; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIContextMenuInteraction interaction, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> WillEndObs => _willEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIContextMenuInteraction interaction, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator)> WillPerformPreviewActionObs => _willPerformPreviewAction; + /// + public override void WillDisplayMenu(global::UIKit.UIContextMenuInteraction interaction, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator) => _willDisplayMenu.OnNext((interaction, configuration, animator)); + /// + public override void WillEnd(global::UIKit.UIContextMenuInteraction interaction, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator) => _willEnd.OnNext((interaction, configuration, animator)); + /// + public override void WillPerformPreviewAction(global::UIKit.UIContextMenuInteraction interaction, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator) => _willPerformPreviewAction.OnNext((interaction, configuration, animator)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIDocumentBrowserViewControllerDelegateRx : global::UIKit.UIDocumentBrowserViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl sourceUrl, global::Foundation.NSUrl destinationUrl)> _didImportDocument = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl sourceUrl, global::Foundation.NSUrl destinationUrl)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl[] documentUrls)> _didPickDocumentsAtUrls = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl[] documentUrls)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl[] documentUrls)> _didPickDocumentUrls = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl[] documentUrls)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentBrowserViewController controller, global::System.Action importHandler)> _didRequestDocumentCreation = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentBrowserViewController controller, global::System.Action importHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl documentUrl, global::Foundation.NSError error)> _failedToImportDocument = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl documentUrl, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentBrowserViewController controller, global::UIKit.UIActivityViewController activityViewController)> _willPresent = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentBrowserViewController controller, global::UIKit.UIActivityViewController activityViewController)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl sourceUrl, global::Foundation.NSUrl destinationUrl)> DidImportDocumentObs => _didImportDocument; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl[] documentUrls)> DidPickDocumentsAtUrlsObs => _didPickDocumentsAtUrls; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl[] documentUrls)> DidPickDocumentUrlsObs => _didPickDocumentUrls; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDocumentBrowserViewController controller, global::System.Action importHandler)> DidRequestDocumentCreationObs => _didRequestDocumentCreation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl documentUrl, global::Foundation.NSError error)> FailedToImportDocumentObs => _failedToImportDocument; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDocumentBrowserViewController controller, global::UIKit.UIActivityViewController activityViewController)> WillPresentObs => _willPresent; + /// + public override void DidImportDocument(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl sourceUrl, global::Foundation.NSUrl destinationUrl) => _didImportDocument.OnNext((controller, sourceUrl, destinationUrl)); + /// + public override void DidPickDocumentsAtUrls(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl[] documentUrls) => _didPickDocumentsAtUrls.OnNext((controller, documentUrls)); + /// + public override void DidPickDocumentUrls(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl[] documentUrls) => _didPickDocumentUrls.OnNext((controller, documentUrls)); + /// + public override void DidRequestDocumentCreation(global::UIKit.UIDocumentBrowserViewController controller, global::System.Action importHandler) => _didRequestDocumentCreation.OnNext((controller, importHandler)); + /// + public override void FailedToImportDocument(global::UIKit.UIDocumentBrowserViewController controller, global::Foundation.NSUrl documentUrl, global::Foundation.NSError error) => _failedToImportDocument.OnNext((controller, documentUrl, error)); + /// + public override void WillPresent(global::UIKit.UIDocumentBrowserViewController controller, global::UIKit.UIActivityViewController activityViewController) => _willPresent.OnNext((controller, activityViewController)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIDocumentInteractionControllerDelegateRx : global::UIKit.UIDocumentInteractionControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didDismissOpenInMenu = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didDismissOptionsMenu = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEndPreview = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentInteractionController controller, string application)> _didEndSendingToApplication = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentInteractionController controller, string application)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willBeginPreview = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentInteractionController controller, string application)> _willBeginSendingToApplication = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentInteractionController controller, string application)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willPresentOpenInMenu = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willPresentOptionsMenu = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDismissOpenInMenuObs => _didDismissOpenInMenu; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDismissOptionsMenuObs => _didDismissOptionsMenu; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndPreviewObs => _didEndPreview; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDocumentInteractionController controller, string application)> DidEndSendingToApplicationObs => _didEndSendingToApplication; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillBeginPreviewObs => _willBeginPreview; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDocumentInteractionController controller, string application)> WillBeginSendingToApplicationObs => _willBeginSendingToApplication; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillPresentOpenInMenuObs => _willPresentOpenInMenu; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillPresentOptionsMenuObs => _willPresentOptionsMenu; + /// + public override void DidDismissOpenInMenu(global::UIKit.UIDocumentInteractionController controller) => _didDismissOpenInMenu.OnNext(controller); + /// + public override void DidDismissOptionsMenu(global::UIKit.UIDocumentInteractionController controller) => _didDismissOptionsMenu.OnNext(controller); + /// + public override void DidEndPreview(global::UIKit.UIDocumentInteractionController controller) => _didEndPreview.OnNext(controller); + /// + public override void DidEndSendingToApplication(global::UIKit.UIDocumentInteractionController controller, string application) => _didEndSendingToApplication.OnNext((controller, application)); + /// + public override void WillBeginPreview(global::UIKit.UIDocumentInteractionController controller) => _willBeginPreview.OnNext(controller); + /// + public override void WillBeginSendingToApplication(global::UIKit.UIDocumentInteractionController controller, string application) => _willBeginSendingToApplication.OnNext((controller, application)); + /// + public override void WillPresentOpenInMenu(global::UIKit.UIDocumentInteractionController controller) => _willPresentOpenInMenu.OnNext(controller); + /// + public override void WillPresentOptionsMenu(global::UIKit.UIDocumentInteractionController controller) => _willPresentOptionsMenu.OnNext(controller); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UIDocumentMenuDelegateRx : global::UIKit.UIDocumentMenuDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentMenuViewController documentMenu, global::UIKit.UIDocumentPickerViewController documentPicker)> _didPickDocumentPicker = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentMenuViewController documentMenu, global::UIKit.UIDocumentPickerViewController documentPicker)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _wasCancelled = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDocumentMenuViewController documentMenu, global::UIKit.UIDocumentPickerViewController documentPicker)> DidPickDocumentPickerObs => _didPickDocumentPicker; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WasCancelledObs => _wasCancelled; + /// + public override void DidPickDocumentPicker(global::UIKit.UIDocumentMenuViewController documentMenu, global::UIKit.UIDocumentPickerViewController documentPicker) => _didPickDocumentPicker.OnNext((documentMenu, documentPicker)); + /// + public override void WasCancelled(global::UIKit.UIDocumentMenuViewController documentMenu) => _wasCancelled.OnNext(documentMenu); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UIDocumentPickerDelegateRx : global::UIKit.UIDocumentPickerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentPickerViewController controller, global::Foundation.NSUrl url)> _didPickDocument = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDocumentPickerViewController controller, global::Foundation.NSUrl url)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _wasCancelled = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDocumentPickerViewController controller, global::Foundation.NSUrl url)> DidPickDocumentObs => _didPickDocument; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WasCancelledObs => _wasCancelled; + /// + public override void DidPickDocument(global::UIKit.UIDocumentPickerViewController controller, global::Foundation.NSUrl url) => _didPickDocument.OnNext((controller, url)); + /// + public override void WasCancelled(global::UIKit.UIDocumentPickerViewController controller) => _wasCancelled.OnNext(controller); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UIDragInteractionDelegateRx : global::UIKit.UIDragInteractionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session, global::UIKit.UIDropOperation operation)> _sessionDidEnd = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session, global::UIKit.UIDropOperation operation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session)> _sessionDidMove = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session)> _sessionDidTransferItems = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session)> _sessionWillBegin = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session, global::UIKit.UIDropOperation operation)> _sessionWillEnd = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session, global::UIKit.UIDropOperation operation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session, global::UIKit.UIDragItem[] items, global::UIKit.UIDragInteraction addingInteraction)> _willAddItems = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session, global::UIKit.UIDragItem[] items, global::UIKit.UIDragInteraction addingInteraction)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.UIDragItem item, global::UIKit.IUIDragAnimating animator)> _willAnimateCancel = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.UIDragItem item, global::UIKit.IUIDragAnimating animator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragAnimating animator, global::UIKit.IUIDragSession session)> _willAnimateLift = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragAnimating animator, global::UIKit.IUIDragSession session)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session, global::UIKit.UIDropOperation operation)> SessionDidEndObs => _sessionDidEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session)> SessionDidMoveObs => _sessionDidMove; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session)> SessionDidTransferItemsObs => _sessionDidTransferItems; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session)> SessionWillBeginObs => _sessionWillBegin; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session, global::UIKit.UIDropOperation operation)> SessionWillEndObs => _sessionWillEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session, global::UIKit.UIDragItem[] items, global::UIKit.UIDragInteraction addingInteraction)> WillAddItemsObs => _willAddItems; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDragInteraction interaction, global::UIKit.UIDragItem item, global::UIKit.IUIDragAnimating animator)> WillAnimateCancelObs => _willAnimateCancel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragAnimating animator, global::UIKit.IUIDragSession session)> WillAnimateLiftObs => _willAnimateLift; + /// + public override void SessionDidEnd(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session, global::UIKit.UIDropOperation operation) => _sessionDidEnd.OnNext((interaction, session, operation)); + /// + public override void SessionDidMove(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session) => _sessionDidMove.OnNext((interaction, session)); + /// + public override void SessionDidTransferItems(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session) => _sessionDidTransferItems.OnNext((interaction, session)); + /// + public override void SessionWillBegin(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session) => _sessionWillBegin.OnNext((interaction, session)); + /// + public override void SessionWillEnd(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session, global::UIKit.UIDropOperation operation) => _sessionWillEnd.OnNext((interaction, session, operation)); + /// + public override void WillAddItems(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragSession session, global::UIKit.UIDragItem[] items, global::UIKit.UIDragInteraction addingInteraction) => _willAddItems.OnNext((interaction, session, items, addingInteraction)); + /// + public override void WillAnimateCancel(global::UIKit.UIDragInteraction interaction, global::UIKit.UIDragItem item, global::UIKit.IUIDragAnimating animator) => _willAnimateCancel.OnNext((interaction, item, animator)); + /// + public override void WillAnimateLift(global::UIKit.UIDragInteraction interaction, global::UIKit.IUIDragAnimating animator, global::UIKit.IUIDragSession session) => _willAnimateLift.OnNext((interaction, animator, session)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIDropInteractionDelegateRx : global::UIKit.UIDropInteractionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session)> _concludeDrop = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session)> _performDrop = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session)> _sessionDidEnd = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session)> _sessionDidEnter = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session)> _sessionDidExit = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDropInteraction interaction, global::UIKit.UIDragItem item, global::UIKit.IUIDragAnimating animator)> _willAnimateDrop = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIDropInteraction interaction, global::UIKit.UIDragItem item, global::UIKit.IUIDragAnimating animator)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session)> ConcludeDropObs => _concludeDrop; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session)> PerformDropObs => _performDrop; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session)> SessionDidEndObs => _sessionDidEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session)> SessionDidEnterObs => _sessionDidEnter; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session)> SessionDidExitObs => _sessionDidExit; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIDropInteraction interaction, global::UIKit.UIDragItem item, global::UIKit.IUIDragAnimating animator)> WillAnimateDropObs => _willAnimateDrop; + /// + public override void ConcludeDrop(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session) => _concludeDrop.OnNext((interaction, session)); + /// + public override void PerformDrop(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session) => _performDrop.OnNext((interaction, session)); + /// + public override void SessionDidEnd(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session) => _sessionDidEnd.OnNext((interaction, session)); + /// + public override void SessionDidEnter(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session) => _sessionDidEnter.OnNext((interaction, session)); + /// + public override void SessionDidExit(global::UIKit.UIDropInteraction interaction, global::UIKit.IUIDropSession session) => _sessionDidExit.OnNext((interaction, session)); + /// + public override void WillAnimateDrop(global::UIKit.UIDropInteraction interaction, global::UIKit.UIDragItem item, global::UIKit.IUIDragAnimating animator) => _willAnimateDrop.OnNext((interaction, item, animator)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UIDynamicAnimatorDelegateRx : global::UIKit.UIDynamicAnimatorDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didPause = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willResume = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidPauseObs => _didPause; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillResumeObs => _willResume; + /// + public override void DidPause(global::UIKit.UIDynamicAnimator animator) => _didPause.OnNext(animator); + /// + public override void WillResume(global::UIKit.UIDynamicAnimator animator) => _willResume.OnNext(animator); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIFontPickerViewControllerDelegateRx : global::UIKit.UIFontPickerViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didCancel = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didPickFont = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidCancelObs => _didCancel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidPickFontObs => _didPickFont; + /// + public override void DidCancel(global::UIKit.UIFontPickerViewController viewController) => _didCancel.OnNext(viewController); + /// + public override void DidPickFont(global::UIKit.UIFontPickerViewController viewController) => _didPickFont.OnNext(viewController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIImagePickerControllerDelegateRx : global::UIKit.UIImagePickerControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _canceled = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIImagePickerController picker, global::UIKit.UIImage image, global::Foundation.NSDictionary editingInfo)> _finishedPickingImage = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIImagePickerController picker, global::UIKit.UIImage image, global::Foundation.NSDictionary editingInfo)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIImagePickerController picker, global::Foundation.NSDictionary info)> _finishedPickingMedia = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIImagePickerController picker, global::Foundation.NSDictionary info)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable CanceledObs => _canceled; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIImagePickerController picker, global::UIKit.UIImage image, global::Foundation.NSDictionary editingInfo)> FinishedPickingImageObs => _finishedPickingImage; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIImagePickerController picker, global::Foundation.NSDictionary info)> FinishedPickingMediaObs => _finishedPickingMedia; + /// + public override void Canceled(global::UIKit.UIImagePickerController picker) => _canceled.OnNext(picker); + /// + public override void FinishedPickingImage(global::UIKit.UIImagePickerController picker, global::UIKit.UIImage image, global::Foundation.NSDictionary editingInfo) => _finishedPickingImage.OnNext((picker, image, editingInfo)); + /// + public override void FinishedPickingMedia(global::UIKit.UIImagePickerController picker, global::Foundation.NSDictionary info) => _finishedPickingMedia.OnNext((picker, info)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UIIndirectScribbleInteractionDelegateRx : global::UIKit.UIIndirectScribbleInteractionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIIndirectScribbleInteraction interaction, global::Foundation.NSObject elementIdentifier)> _didFinishWriting = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIIndirectScribbleInteraction interaction, global::Foundation.NSObject elementIdentifier)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIIndirectScribbleInteraction interaction, global::Foundation.NSObject elementIdentifier, global::CoreGraphics.CGPoint focusReferencePoint, global::System.Action completion)> _focusElementIfNeeded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIIndirectScribbleInteraction interaction, global::Foundation.NSObject elementIdentifier, global::CoreGraphics.CGPoint focusReferencePoint, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIIndirectScribbleInteraction interaction, global::CoreGraphics.CGRect rect, global::System.Action completion)> _requestElements = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIIndirectScribbleInteraction interaction, global::CoreGraphics.CGRect rect, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIIndirectScribbleInteraction interaction, global::Foundation.NSObject elementIdentifier)> _willBeginWriting = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIIndirectScribbleInteraction interaction, global::Foundation.NSObject elementIdentifier)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIIndirectScribbleInteraction interaction, global::Foundation.NSObject elementIdentifier)> DidFinishWritingObs => _didFinishWriting; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIIndirectScribbleInteraction interaction, global::Foundation.NSObject elementIdentifier, global::CoreGraphics.CGPoint focusReferencePoint, global::System.Action completion)> FocusElementIfNeededObs => _focusElementIfNeeded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIIndirectScribbleInteraction interaction, global::CoreGraphics.CGRect rect, global::System.Action completion)> RequestElementsObs => _requestElements; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIIndirectScribbleInteraction interaction, global::Foundation.NSObject elementIdentifier)> WillBeginWritingObs => _willBeginWriting; + /// + public override void DidFinishWriting(global::UIKit.UIIndirectScribbleInteraction interaction, global::Foundation.NSObject elementIdentifier) => _didFinishWriting.OnNext((interaction, elementIdentifier)); + /// + public override void FocusElementIfNeeded(global::UIKit.UIIndirectScribbleInteraction interaction, global::Foundation.NSObject elementIdentifier, global::CoreGraphics.CGPoint focusReferencePoint, global::System.Action completion) => _focusElementIfNeeded.OnNext((interaction, elementIdentifier, focusReferencePoint, completion)); + /// + public override void RequestElements(global::UIKit.UIIndirectScribbleInteraction interaction, global::CoreGraphics.CGRect rect, global::System.Action completion) => _requestElements.OnNext((interaction, rect, completion)); + /// + public override void WillBeginWriting(global::UIKit.UIIndirectScribbleInteraction interaction, global::Foundation.NSObject elementIdentifier) => _willBeginWriting.OnNext((interaction, elementIdentifier)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UILargeContentViewerInteractionDelegateRx : global::UIKit.UILargeContentViewerInteractionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UILargeContentViewerInteraction interaction, global::UIKit.IUILargeContentViewerItem item, global::CoreGraphics.CGPoint point)> _didEnd = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UILargeContentViewerInteraction interaction, global::UIKit.IUILargeContentViewerItem item, global::CoreGraphics.CGPoint point)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UILargeContentViewerInteraction interaction, global::UIKit.IUILargeContentViewerItem item, global::CoreGraphics.CGPoint point)> DidEndObs => _didEnd; + /// + public override void DidEnd(global::UIKit.UILargeContentViewerInteraction interaction, global::UIKit.IUILargeContentViewerItem item, global::CoreGraphics.CGPoint point) => _didEnd.OnNext((interaction, item, point)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UINavigationBarDelegateRx : global::UIKit.UINavigationBarDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UINavigationBar navigationBar, global::UIKit.UINavigationItem item)> _didPopItem = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UINavigationBar navigationBar, global::UIKit.UINavigationItem item)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UINavigationBar navigationBar, global::UIKit.UINavigationItem item)> _didPushItem = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UINavigationBar navigationBar, global::UIKit.UINavigationItem item)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UINavigationBar navigationBar, global::UIKit.UINavigationItem item)> DidPopItemObs => _didPopItem; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UINavigationBar navigationBar, global::UIKit.UINavigationItem item)> DidPushItemObs => _didPushItem; + /// + public override void DidPopItem(global::UIKit.UINavigationBar navigationBar, global::UIKit.UINavigationItem item) => _didPopItem.OnNext((navigationBar, item)); + /// + public override void DidPushItem(global::UIKit.UINavigationBar navigationBar, global::UIKit.UINavigationItem item) => _didPushItem.OnNext((navigationBar, item)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UINavigationControllerDelegateRx : global::UIKit.UINavigationControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UINavigationController navigationController, global::UIKit.UIViewController viewController, bool animated)> _didShowViewController = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UINavigationController navigationController, global::UIKit.UIViewController viewController, bool animated)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UINavigationController navigationController, global::UIKit.UIViewController viewController, bool animated)> _willShowViewController = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UINavigationController navigationController, global::UIKit.UIViewController viewController, bool animated)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UINavigationController navigationController, global::UIKit.UIViewController viewController, bool animated)> DidShowViewControllerObs => _didShowViewController; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UINavigationController navigationController, global::UIKit.UIViewController viewController, bool animated)> WillShowViewControllerObs => _willShowViewController; + /// + public override void DidShowViewController(global::UIKit.UINavigationController navigationController, global::UIKit.UIViewController viewController, bool animated) => _didShowViewController.OnNext((navigationController, viewController, animated)); + /// + public override void WillShowViewController(global::UIKit.UINavigationController navigationController, global::UIKit.UIViewController viewController, bool animated) => _willShowViewController.OnNext((navigationController, viewController, animated)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIPageViewControllerDelegateRx : global::UIKit.UIPageViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPageViewController pageViewController, bool finished, global::UIKit.UIViewController[] previousViewControllers, bool completed)> _didFinishAnimating = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPageViewController pageViewController, bool finished, global::UIKit.UIViewController[] previousViewControllers, bool completed)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPageViewController pageViewController, global::UIKit.UIViewController[] pendingViewControllers)> _willTransition = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPageViewController pageViewController, global::UIKit.UIViewController[] pendingViewControllers)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIPageViewController pageViewController, bool finished, global::UIKit.UIViewController[] previousViewControllers, bool completed)> DidFinishAnimatingObs => _didFinishAnimating; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIPageViewController pageViewController, global::UIKit.UIViewController[] pendingViewControllers)> WillTransitionObs => _willTransition; + /// + public override void DidFinishAnimating(global::UIKit.UIPageViewController pageViewController, bool finished, global::UIKit.UIViewController[] previousViewControllers, bool completed) => _didFinishAnimating.OnNext((pageViewController, finished, previousViewControllers, completed)); + /// + public override void WillTransition(global::UIKit.UIPageViewController pageViewController, global::UIKit.UIViewController[] pendingViewControllers) => _willTransition.OnNext((pageViewController, pendingViewControllers)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIPencilInteractionDelegateRx : global::UIKit.UIPencilInteractionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didTap = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidTapObs => _didTap; + /// + public override void DidTap(global::UIKit.UIPencilInteraction interaction) => _didTap.OnNext(interaction); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIPickerViewDelegateRx : global::UIKit.UIPickerViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPickerView pickerView, global::System.nint row, global::System.nint component)> _selected = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPickerView pickerView, global::System.nint row, global::System.nint component)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIPickerView pickerView, global::System.nint row, global::System.nint component)> SelectedObs => _selected; + /// + public override void Selected(global::UIKit.UIPickerView pickerView, global::System.nint row, global::System.nint component) => _selected.OnNext((pickerView, row, component)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIPointerInteractionDelegateRx : global::UIKit.UIPointerInteractionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPointerInteraction interaction, global::UIKit.UIPointerRegion region, global::UIKit.IUIPointerInteractionAnimating animator)> _willEnterRegion = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPointerInteraction interaction, global::UIKit.UIPointerRegion region, global::UIKit.IUIPointerInteractionAnimating animator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPointerInteraction interaction, global::UIKit.UIPointerRegion region, global::UIKit.IUIPointerInteractionAnimating animator)> _willExitRegion = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPointerInteraction interaction, global::UIKit.UIPointerRegion region, global::UIKit.IUIPointerInteractionAnimating animator)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIPointerInteraction interaction, global::UIKit.UIPointerRegion region, global::UIKit.IUIPointerInteractionAnimating animator)> WillEnterRegionObs => _willEnterRegion; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIPointerInteraction interaction, global::UIKit.UIPointerRegion region, global::UIKit.IUIPointerInteractionAnimating animator)> WillExitRegionObs => _willExitRegion; + /// + public override void WillEnterRegion(global::UIKit.UIPointerInteraction interaction, global::UIKit.UIPointerRegion region, global::UIKit.IUIPointerInteractionAnimating animator) => _willEnterRegion.OnNext((interaction, region, animator)); + /// + public override void WillExitRegion(global::UIKit.UIPointerInteraction interaction, global::UIKit.UIPointerRegion region, global::UIKit.IUIPointerInteractionAnimating animator) => _willExitRegion.OnNext((interaction, region, animator)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIPopoverControllerDelegateRx : global::UIKit.UIPopoverControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didDismiss = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDismissObs => _didDismiss; + /// + public override void DidDismiss(global::UIKit.UIPopoverController popoverController) => _didDismiss.OnNext(popoverController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIPopoverPresentationControllerDelegateRx : global::UIKit.UIPopoverPresentationControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didDismissPopover = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _prepareForPopoverPresentation = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPopoverPresentationController popoverPresentationController, global::CoreGraphics.CGRect targetRect, global::UIKit.UIView inView)> _willRepositionPopover = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPopoverPresentationController popoverPresentationController, global::CoreGraphics.CGRect targetRect, global::UIKit.UIView inView)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDismissPopoverObs => _didDismissPopover; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PrepareForPopoverPresentationObs => _prepareForPopoverPresentation; + /// + /// Gets an observable which signals when the method is invoked. + /// + [global::System.ObsoleteAttribute("Use the overload with 'ref' parameters for 'targetRect' and 'inView'.", false)] + public global::System.IObservable<(global::UIKit.UIPopoverPresentationController popoverPresentationController, global::CoreGraphics.CGRect targetRect, global::UIKit.UIView inView)> WillRepositionPopoverObs => _willRepositionPopover; + /// + public override void DidDismissPopover(global::UIKit.UIPopoverPresentationController popoverPresentationController) => _didDismissPopover.OnNext(popoverPresentationController); + /// + public override void PrepareForPopoverPresentation(global::UIKit.UIPopoverPresentationController popoverPresentationController) => _prepareForPopoverPresentation.OnNext(popoverPresentationController); + /// + [global::System.ObsoleteAttribute("Use the overload with 'ref' parameters for 'targetRect' and 'inView'.", false)] + public override void WillRepositionPopover(global::UIKit.UIPopoverPresentationController popoverPresentationController, global::CoreGraphics.CGRect targetRect, global::UIKit.UIView inView) => _willRepositionPopover.OnNext((popoverPresentationController, targetRect, inView)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UIPreviewInteractionDelegateRx : global::UIKit.UIPreviewInteractionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didCancel = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPreviewInteraction previewInteraction, global::System.nfloat transitionProgress, bool ended)> _didUpdateCommit = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPreviewInteraction previewInteraction, global::System.nfloat transitionProgress, bool ended)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPreviewInteraction previewInteraction, global::System.nfloat transitionProgress, bool ended)> _didUpdatePreviewTransition = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIPreviewInteraction previewInteraction, global::System.nfloat transitionProgress, bool ended)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidCancelObs => _didCancel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIPreviewInteraction previewInteraction, global::System.nfloat transitionProgress, bool ended)> DidUpdateCommitObs => _didUpdateCommit; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIPreviewInteraction previewInteraction, global::System.nfloat transitionProgress, bool ended)> DidUpdatePreviewTransitionObs => _didUpdatePreviewTransition; + /// + public override void DidCancel(global::UIKit.UIPreviewInteraction previewInteraction) => _didCancel.OnNext(previewInteraction); + /// + public override void DidUpdateCommit(global::UIKit.UIPreviewInteraction previewInteraction, global::System.nfloat transitionProgress, bool ended) => _didUpdateCommit.OnNext((previewInteraction, transitionProgress, ended)); + /// + public override void DidUpdatePreviewTransition(global::UIKit.UIPreviewInteraction previewInteraction, global::System.nfloat transitionProgress, bool ended) => _didUpdatePreviewTransition.OnNext((previewInteraction, transitionProgress, ended)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIPrinterPickerControllerDelegateRx : global::UIKit.UIPrinterPickerControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didDismiss = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didPresent = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didSelectPrinter = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willDismiss = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willPresent = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDismissObs => _didDismiss; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidPresentObs => _didPresent; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidSelectPrinterObs => _didSelectPrinter; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillDismissObs => _willDismiss; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillPresentObs => _willPresent; + /// + public override void DidDismiss(global::UIKit.UIPrinterPickerController printerPickerController) => _didDismiss.OnNext(printerPickerController); + /// + public override void DidPresent(global::UIKit.UIPrinterPickerController printerPickerController) => _didPresent.OnNext(printerPickerController); + /// + public override void DidSelectPrinter(global::UIKit.UIPrinterPickerController printerPickerController) => _didSelectPrinter.OnNext(printerPickerController); + /// + public override void WillDismiss(global::UIKit.UIPrinterPickerController printerPickerController) => _willDismiss.OnNext(printerPickerController); + /// + public override void WillPresent(global::UIKit.UIPrinterPickerController printerPickerController) => _willPresent.OnNext(printerPickerController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIPrintInteractionControllerDelegateRx : global::UIKit.UIPrintInteractionControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didDismissPrinterOptions = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinishJob = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didPresentPrinterOptions = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willDismissPrinterOptions = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willPresentPrinterOptions = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStartJob = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDismissPrinterOptionsObs => _didDismissPrinterOptions; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishJobObs => _didFinishJob; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidPresentPrinterOptionsObs => _didPresentPrinterOptions; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillDismissPrinterOptionsObs => _willDismissPrinterOptions; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillPresentPrinterOptionsObs => _willPresentPrinterOptions; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStartJobObs => _willStartJob; + /// + public override void DidDismissPrinterOptions(global::UIKit.UIPrintInteractionController printInteractionController) => _didDismissPrinterOptions.OnNext(printInteractionController); + /// + public override void DidFinishJob(global::UIKit.UIPrintInteractionController printInteractionController) => _didFinishJob.OnNext(printInteractionController); + /// + public override void DidPresentPrinterOptions(global::UIKit.UIPrintInteractionController printInteractionController) => _didPresentPrinterOptions.OnNext(printInteractionController); + /// + public override void WillDismissPrinterOptions(global::UIKit.UIPrintInteractionController printInteractionController) => _willDismissPrinterOptions.OnNext(printInteractionController); + /// + public override void WillPresentPrinterOptions(global::UIKit.UIPrintInteractionController printInteractionController) => _willPresentPrinterOptions.OnNext(printInteractionController); + /// + public override void WillStartJob(global::UIKit.UIPrintInteractionController printInteractionController) => _willStartJob.OnNext(printInteractionController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UISceneDelegateRx : global::UIKit.UISceneDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> _continueUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeActive = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didDisconnect = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEnterBackground = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error)> _didFailToContinueUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> _didUpdateUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts)> _openUrlContexts = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions)> _willConnect = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType)> _willContinueUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willEnterForeground = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willResignActive = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> ContinueUserActivityObs => _continueUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeActiveObs => _didBecomeActive; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDisconnectObs => _didDisconnect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEnterBackgroundObs => _didEnterBackground; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error)> DidFailToContinueUserActivityObs => _didFailToContinueUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> DidUpdateUserActivityObs => _didUpdateUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts)> OpenUrlContextsObs => _openUrlContexts; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions)> WillConnectObs => _willConnect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, string userActivityType)> WillContinueUserActivityObs => _willContinueUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillEnterForegroundObs => _willEnterForeground; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillResignActiveObs => _willResignActive; + /// + public override void ContinueUserActivity(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity) => _continueUserActivity.OnNext((scene, userActivity)); + /// + public override void DidBecomeActive(global::UIKit.UIScene scene) => _didBecomeActive.OnNext(scene); + /// + public override void DidDisconnect(global::UIKit.UIScene scene) => _didDisconnect.OnNext(scene); + /// + public override void DidEnterBackground(global::UIKit.UIScene scene) => _didEnterBackground.OnNext(scene); + /// + public override void DidFailToContinueUserActivity(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error) => _didFailToContinueUserActivity.OnNext((scene, userActivityType, error)); + /// + public override void DidUpdateUserActivity(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity) => _didUpdateUserActivity.OnNext((scene, userActivity)); + /// + public override void OpenUrlContexts(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts) => _openUrlContexts.OnNext((scene, urlContexts)); + /// + public override void WillConnect(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions) => _willConnect.OnNext((scene, session, connectionOptions)); + /// + public override void WillContinueUserActivity(global::UIKit.UIScene scene, string userActivityType) => _willContinueUserActivity.OnNext((scene, userActivityType)); + /// + public override void WillEnterForeground(global::UIKit.UIScene scene) => _willEnterForeground.OnNext(scene); + /// + public override void WillResignActive(global::UIKit.UIScene scene) => _willResignActive.OnNext(scene); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIScreenshotServiceDelegateRx : global::UIKit.UIScreenshotServiceDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScreenshotService screenshotService, global::UIKit.UIScreenshotServiceDelegatePdfHandler completionHandler)> _generatePdfRepresentation = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScreenshotService screenshotService, global::UIKit.UIScreenshotServiceDelegatePdfHandler completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScreenshotService screenshotService, global::UIKit.UIScreenshotServiceDelegatePdfHandler completionHandler)> GeneratePdfRepresentationObs => _generatePdfRepresentation; + /// + public override void GeneratePdfRepresentation(global::UIKit.UIScreenshotService screenshotService, global::UIKit.UIScreenshotServiceDelegatePdfHandler completionHandler) => _generatePdfRepresentation.OnNext((screenshotService, completionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIScribbleInteractionDelegateRx : global::UIKit.UIScribbleInteractionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didFinishWriting = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willBeginWriting = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishWritingObs => _didFinishWriting; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillBeginWritingObs => _willBeginWriting; + /// + public override void DidFinishWriting(global::UIKit.UIScribbleInteraction interaction) => _didFinishWriting.OnNext(interaction); + /// + public override void WillBeginWriting(global::UIKit.UIScribbleInteraction interaction) => _willBeginWriting.OnNext(interaction); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIScrollViewDelegateRx : global::UIKit.UIScrollViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _decelerationEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _decelerationStarted = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeAdjustedContentInset = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didZoom = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, bool willDecelerate)> _draggingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, bool willDecelerate)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _draggingStarted = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _scrollAnimationEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _scrolled = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _scrolledToTop = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView withView, global::System.nfloat atScale)> _zoomingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView withView, global::System.nfloat atScale)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView view)> _zoomingStarted = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView view)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DecelerationEndedObs => _decelerationEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DecelerationStartedObs => _decelerationStarted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeAdjustedContentInsetObs => _didChangeAdjustedContentInset; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidZoomObs => _didZoom; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScrollView scrollView, bool willDecelerate)> DraggingEndedObs => _draggingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DraggingStartedObs => _draggingStarted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ScrollAnimationEndedObs => _scrollAnimationEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ScrolledObs => _scrolled; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ScrolledToTopObs => _scrolledToTop; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView withView, global::System.nfloat atScale)> ZoomingEndedObs => _zoomingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScrollView scrollView, global::UIKit.UIView view)> ZoomingStartedObs => _zoomingStarted; + /// + public override void DecelerationEnded(global::UIKit.UIScrollView scrollView) => _decelerationEnded.OnNext(scrollView); + /// + public override void DecelerationStarted(global::UIKit.UIScrollView scrollView) => _decelerationStarted.OnNext(scrollView); + /// + public override void DidChangeAdjustedContentInset(global::UIKit.UIScrollView scrollView) => _didChangeAdjustedContentInset.OnNext(scrollView); + /// + public override void DidZoom(global::UIKit.UIScrollView scrollView) => _didZoom.OnNext(scrollView); + /// + public override void DraggingEnded(global::UIKit.UIScrollView scrollView, bool willDecelerate) => _draggingEnded.OnNext((scrollView, willDecelerate)); + /// + public override void DraggingStarted(global::UIKit.UIScrollView scrollView) => _draggingStarted.OnNext(scrollView); + /// + public override void ScrollAnimationEnded(global::UIKit.UIScrollView scrollView) => _scrollAnimationEnded.OnNext(scrollView); + /// + public override void Scrolled(global::UIKit.UIScrollView scrollView) => _scrolled.OnNext(scrollView); + /// + public override void ScrolledToTop(global::UIKit.UIScrollView scrollView) => _scrolledToTop.OnNext(scrollView); + /// + public override void ZoomingEnded(global::UIKit.UIScrollView scrollView, global::UIKit.UIView withView, global::System.nfloat atScale) => _zoomingEnded.OnNext((scrollView, withView, atScale)); + /// + public override void ZoomingStarted(global::UIKit.UIScrollView scrollView, global::UIKit.UIView view) => _zoomingStarted.OnNext((scrollView, view)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UISearchBarDelegateRx : global::UIKit.UISearchBarDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _bookmarkButtonClicked = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _cancelButtonClicked = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _listButtonClicked = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _onEditingStarted = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _onEditingStopped = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _searchButtonClicked = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchBar searchBar, global::System.nint selectedScope)> _selectedScopeButtonIndexChanged = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchBar searchBar, global::System.nint selectedScope)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchBar searchBar, string searchText)> _textChanged = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchBar searchBar, string searchText)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable BookmarkButtonClickedObs => _bookmarkButtonClicked; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable CancelButtonClickedObs => _cancelButtonClicked; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ListButtonClickedObs => _listButtonClicked; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OnEditingStartedObs => _onEditingStarted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OnEditingStoppedObs => _onEditingStopped; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SearchButtonClickedObs => _searchButtonClicked; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UISearchBar searchBar, global::System.nint selectedScope)> SelectedScopeButtonIndexChangedObs => _selectedScopeButtonIndexChanged; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UISearchBar searchBar, string searchText)> TextChangedObs => _textChanged; + /// + public override void BookmarkButtonClicked(global::UIKit.UISearchBar searchBar) => _bookmarkButtonClicked.OnNext(searchBar); + /// + public override void CancelButtonClicked(global::UIKit.UISearchBar searchBar) => _cancelButtonClicked.OnNext(searchBar); + /// + public override void ListButtonClicked(global::UIKit.UISearchBar searchBar) => _listButtonClicked.OnNext(searchBar); + /// + public override void OnEditingStarted(global::UIKit.UISearchBar searchBar) => _onEditingStarted.OnNext(searchBar); + /// + public override void OnEditingStopped(global::UIKit.UISearchBar searchBar) => _onEditingStopped.OnNext(searchBar); + /// + public override void SearchButtonClicked(global::UIKit.UISearchBar searchBar) => _searchButtonClicked.OnNext(searchBar); + /// + public override void SelectedScopeButtonIndexChanged(global::UIKit.UISearchBar searchBar, global::System.nint selectedScope) => _selectedScopeButtonIndexChanged.OnNext((searchBar, selectedScope)); + /// + public override void TextChanged(global::UIKit.UISearchBar searchBar, string searchText) => _textChanged.OnNext((searchBar, searchText)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UISearchControllerDelegateRx : global::UIKit.UISearchControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didDismissSearchController = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didPresentSearchController = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _presentSearchController = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willDismissSearchController = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willPresentSearchController = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDismissSearchControllerObs => _didDismissSearchController; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidPresentSearchControllerObs => _didPresentSearchController; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PresentSearchControllerObs => _presentSearchController; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillDismissSearchControllerObs => _willDismissSearchController; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillPresentSearchControllerObs => _willPresentSearchController; + /// + public override void DidDismissSearchController(global::UIKit.UISearchController searchController) => _didDismissSearchController.OnNext(searchController); + /// + public override void DidPresentSearchController(global::UIKit.UISearchController searchController) => _didPresentSearchController.OnNext(searchController); + /// + public override void PresentSearchController(global::UIKit.UISearchController searchController) => _presentSearchController.OnNext(searchController); + /// + public override void WillDismissSearchController(global::UIKit.UISearchController searchController) => _willDismissSearchController.OnNext(searchController); + /// + public override void WillPresentSearchController(global::UIKit.UISearchController searchController) => _willPresentSearchController.OnNext(searchController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UISearchDisplayDelegateRx : global::UIKit.UISearchDisplayDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBeginSearch = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEndSearch = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)> _didHideSearchResults = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)> _didLoadSearchResults = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)> _didShowSearchResults = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willBeginSearch = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willEndSearch = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)> _willHideSearchResults = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)> _willShowSearchResults = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)> _willUnloadSearchResults = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBeginSearchObs => _didBeginSearch; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndSearchObs => _didEndSearch; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)> DidHideSearchResultsObs => _didHideSearchResults; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)> DidLoadSearchResultsObs => _didLoadSearchResults; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)> DidShowSearchResultsObs => _didShowSearchResults; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillBeginSearchObs => _willBeginSearch; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillEndSearchObs => _willEndSearch; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)> WillHideSearchResultsObs => _willHideSearchResults; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)> WillShowSearchResultsObs => _willShowSearchResults; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView)> WillUnloadSearchResultsObs => _willUnloadSearchResults; + /// + public override void DidBeginSearch(global::UIKit.UISearchDisplayController controller) => _didBeginSearch.OnNext(controller); + /// + public override void DidEndSearch(global::UIKit.UISearchDisplayController controller) => _didEndSearch.OnNext(controller); + /// + public override void DidHideSearchResults(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView) => _didHideSearchResults.OnNext((controller, tableView)); + /// + public override void DidLoadSearchResults(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView) => _didLoadSearchResults.OnNext((controller, tableView)); + /// + public override void DidShowSearchResults(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView) => _didShowSearchResults.OnNext((controller, tableView)); + /// + public override void WillBeginSearch(global::UIKit.UISearchDisplayController controller) => _willBeginSearch.OnNext(controller); + /// + public override void WillEndSearch(global::UIKit.UISearchDisplayController controller) => _willEndSearch.OnNext(controller); + /// + public override void WillHideSearchResults(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView) => _willHideSearchResults.OnNext((controller, tableView)); + /// + public override void WillShowSearchResults(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView) => _willShowSearchResults.OnNext((controller, tableView)); + /// + public override void WillUnloadSearchResults(global::UIKit.UISearchDisplayController controller, global::UIKit.UITableView tableView) => _willUnloadSearchResults.OnNext((controller, tableView)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UISearchTextFieldDelegateRx : global::UIKit.UISearchTextFieldDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeSelection = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITextField textField, global::UIKit.UITextFieldDidEndEditingReason reason)> _editingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITextField textField, global::UIKit.UITextFieldDidEndEditingReason reason)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _editingStarted = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeSelectionObs => _didChangeSelection; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITextField textField, global::UIKit.UITextFieldDidEndEditingReason reason)> EditingEndedObs => _editingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable EditingStartedObs => _editingStarted; + /// + public override void DidChangeSelection(global::UIKit.UITextField textField) => _didChangeSelection.OnNext(textField); + /// + public override void EditingEnded(global::UIKit.UITextField textField, global::UIKit.UITextFieldDidEndEditingReason reason) => _editingEnded.OnNext((textField, reason)); + /// + public override void EditingStarted(global::UIKit.UITextField textField) => _editingStarted.OnNext(textField); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UISplitViewControllerDelegateRx : global::UIKit.UISplitViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didCollapse = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didExpand = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _interactivePresentationGestureDidEnd = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _interactivePresentationGestureWillBegin = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISplitViewController svc, global::UIKit.UISplitViewControllerDisplayMode displayMode)> _willChangeDisplayMode = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISplitViewController svc, global::UIKit.UISplitViewControllerDisplayMode displayMode)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISplitViewController splitViewController, global::UIKit.UISplitViewControllerColumn column)> _willHideColumn = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISplitViewController splitViewController, global::UIKit.UISplitViewControllerColumn column)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISplitViewController svc, global::UIKit.UIViewController aViewController, global::UIKit.UIBarButtonItem barButtonItem, global::UIKit.UIPopoverController pc)> _willHideViewController = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISplitViewController svc, global::UIKit.UIViewController aViewController, global::UIKit.UIBarButtonItem barButtonItem, global::UIKit.UIPopoverController pc)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISplitViewController svc, global::UIKit.UIPopoverController pc, global::UIKit.UIViewController aViewController)> _willPresentViewController = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISplitViewController svc, global::UIKit.UIPopoverController pc, global::UIKit.UIViewController aViewController)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISplitViewController splitViewController, global::UIKit.UISplitViewControllerColumn column)> _willShowColumn = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISplitViewController splitViewController, global::UIKit.UISplitViewControllerColumn column)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISplitViewController svc, global::UIKit.UIViewController aViewController, global::UIKit.UIBarButtonItem button)> _willShowViewController = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UISplitViewController svc, global::UIKit.UIViewController aViewController, global::UIKit.UIBarButtonItem button)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidCollapseObs => _didCollapse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidExpandObs => _didExpand; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable InteractivePresentationGestureDidEndObs => _interactivePresentationGestureDidEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable InteractivePresentationGestureWillBeginObs => _interactivePresentationGestureWillBegin; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UISplitViewController svc, global::UIKit.UISplitViewControllerDisplayMode displayMode)> WillChangeDisplayModeObs => _willChangeDisplayMode; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UISplitViewController splitViewController, global::UIKit.UISplitViewControllerColumn column)> WillHideColumnObs => _willHideColumn; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UISplitViewController svc, global::UIKit.UIViewController aViewController, global::UIKit.UIBarButtonItem barButtonItem, global::UIKit.UIPopoverController pc)> WillHideViewControllerObs => _willHideViewController; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UISplitViewController svc, global::UIKit.UIPopoverController pc, global::UIKit.UIViewController aViewController)> WillPresentViewControllerObs => _willPresentViewController; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UISplitViewController splitViewController, global::UIKit.UISplitViewControllerColumn column)> WillShowColumnObs => _willShowColumn; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UISplitViewController svc, global::UIKit.UIViewController aViewController, global::UIKit.UIBarButtonItem button)> WillShowViewControllerObs => _willShowViewController; + /// + public override void DidCollapse(global::UIKit.UISplitViewController splitViewController) => _didCollapse.OnNext(splitViewController); + /// + public override void DidExpand(global::UIKit.UISplitViewController splitViewController) => _didExpand.OnNext(splitViewController); + /// + public override void InteractivePresentationGestureDidEnd(global::UIKit.UISplitViewController svc) => _interactivePresentationGestureDidEnd.OnNext(svc); + /// + public override void InteractivePresentationGestureWillBegin(global::UIKit.UISplitViewController svc) => _interactivePresentationGestureWillBegin.OnNext(svc); + /// + public override void WillChangeDisplayMode(global::UIKit.UISplitViewController svc, global::UIKit.UISplitViewControllerDisplayMode displayMode) => _willChangeDisplayMode.OnNext((svc, displayMode)); + /// + public override void WillHideColumn(global::UIKit.UISplitViewController splitViewController, global::UIKit.UISplitViewControllerColumn column) => _willHideColumn.OnNext((splitViewController, column)); + /// + public override void WillHideViewController(global::UIKit.UISplitViewController svc, global::UIKit.UIViewController aViewController, global::UIKit.UIBarButtonItem barButtonItem, global::UIKit.UIPopoverController pc) => _willHideViewController.OnNext((svc, aViewController, barButtonItem, pc)); + /// + public override void WillPresentViewController(global::UIKit.UISplitViewController svc, global::UIKit.UIPopoverController pc, global::UIKit.UIViewController aViewController) => _willPresentViewController.OnNext((svc, pc, aViewController)); + /// + public override void WillShowColumn(global::UIKit.UISplitViewController splitViewController, global::UIKit.UISplitViewControllerColumn column) => _willShowColumn.OnNext((splitViewController, column)); + /// + public override void WillShowViewController(global::UIKit.UISplitViewController svc, global::UIKit.UIViewController aViewController, global::UIKit.UIBarButtonItem button) => _willShowViewController.OnNext((svc, aViewController, button)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UITabBarControllerDelegateRx : global::UIKit.UITabBarControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController[] viewControllers, bool changed)> _finishedCustomizingViewControllers = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController[] viewControllers, bool changed)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController[] viewControllers)> _onCustomizingViewControllers = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController[] viewControllers)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController[] viewControllers, bool changed)> _onEndCustomizingViewControllers = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController[] viewControllers, bool changed)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController viewController)> _viewControllerSelected = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController viewController)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController[] viewControllers, bool changed)> FinishedCustomizingViewControllersObs => _finishedCustomizingViewControllers; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController[] viewControllers)> OnCustomizingViewControllersObs => _onCustomizingViewControllers; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController[] viewControllers, bool changed)> OnEndCustomizingViewControllersObs => _onEndCustomizingViewControllers; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController viewController)> ViewControllerSelectedObs => _viewControllerSelected; + /// + public override void FinishedCustomizingViewControllers(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController[] viewControllers, bool changed) => _finishedCustomizingViewControllers.OnNext((tabBarController, viewControllers, changed)); + /// + public override void OnCustomizingViewControllers(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController[] viewControllers) => _onCustomizingViewControllers.OnNext((tabBarController, viewControllers)); + /// + public override void OnEndCustomizingViewControllers(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController[] viewControllers, bool changed) => _onEndCustomizingViewControllers.OnNext((tabBarController, viewControllers, changed)); + /// + public override void ViewControllerSelected(global::UIKit.UITabBarController tabBarController, global::UIKit.UIViewController viewController) => _viewControllerSelected.OnNext((tabBarController, viewController)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UITabBarDelegateRx : global::UIKit.UITabBarDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items)> _didBeginCustomizingItems = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items, bool changed)> _didEndCustomizingItems = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items, bool changed)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem item)> _itemSelected = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem item)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items)> _willBeginCustomizingItems = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items, bool changed)> _willEndCustomizingItems = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items, bool changed)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items)> DidBeginCustomizingItemsObs => _didBeginCustomizingItems; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items, bool changed)> DidEndCustomizingItemsObs => _didEndCustomizingItems; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem item)> ItemSelectedObs => _itemSelected; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items)> WillBeginCustomizingItemsObs => _willBeginCustomizingItems; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items, bool changed)> WillEndCustomizingItemsObs => _willEndCustomizingItems; + /// + public override void DidBeginCustomizingItems(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items) => _didBeginCustomizingItems.OnNext((tabbar, items)); + /// + public override void DidEndCustomizingItems(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items, bool changed) => _didEndCustomizingItems.OnNext((tabbar, items, changed)); + /// + public override void ItemSelected(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem item) => _itemSelected.OnNext((tabbar, item)); + /// + public override void WillBeginCustomizingItems(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items) => _willBeginCustomizingItems.OnNext((tabbar, items)); + /// + public override void WillEndCustomizingItems(global::UIKit.UITabBar tabbar, global::UIKit.UITabBarItem[] items, bool changed) => _willEndCustomizingItems.OnNext((tabbar, items, changed)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UITableViewDelegateRx : global::UIKit.UITableViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> _accessoryButtonTapped = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath)> _cellDisplayingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> _didBeginMultipleSelectionInteraction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> _didEndEditing = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEndMultipleSelectionInteraction = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UITableViewFocusUpdateContext context, global::UIKit.UIFocusAnimationCoordinator coordinator)> _didUpdateFocus = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UITableViewFocusUpdateContext context, global::UIKit.UIFocusAnimationCoordinator coordinator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section)> _footerViewDisplayingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section)> _headerViewDisplayingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::ObjCRuntime.Selector action, global::Foundation.NSIndexPath indexPath, global::Foundation.NSObject sender)> _performAction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::ObjCRuntime.Selector action, global::Foundation.NSIndexPath indexPath, global::Foundation.NSObject sender)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> _rowDeselected = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath)> _rowHighlighted = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> _rowSelected = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath)> _rowUnhighlighted = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> _willBeginEditing = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath)> _willDisplay = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> _willDisplayContextMenu = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section)> _willDisplayFooterView = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section)> _willDisplayHeaderView = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> _willEndContextMenuInteraction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator)> _willPerformPreviewAction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> AccessoryButtonTappedObs => _accessoryButtonTapped; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath)> CellDisplayingEndedObs => _cellDisplayingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> DidBeginMultipleSelectionInteractionObs => _didBeginMultipleSelectionInteraction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> DidEndEditingObs => _didEndEditing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndMultipleSelectionInteractionObs => _didEndMultipleSelectionInteraction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UITableViewFocusUpdateContext context, global::UIKit.UIFocusAnimationCoordinator coordinator)> DidUpdateFocusObs => _didUpdateFocus; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section)> FooterViewDisplayingEndedObs => _footerViewDisplayingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section)> HeaderViewDisplayingEndedObs => _headerViewDisplayingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::ObjCRuntime.Selector action, global::Foundation.NSIndexPath indexPath, global::Foundation.NSObject sender)> PerformActionObs => _performAction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> RowDeselectedObs => _rowDeselected; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath)> RowHighlightedObs => _rowHighlighted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> RowSelectedObs => _rowSelected; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath)> RowUnhighlightedObs => _rowUnhighlighted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> WillBeginEditingObs => _willBeginEditing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath)> WillDisplayObs => _willDisplay; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> WillDisplayContextMenuObs => _willDisplayContextMenu; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section)> WillDisplayFooterViewObs => _willDisplayFooterView; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section)> WillDisplayHeaderViewObs => _willDisplayHeaderView; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> WillEndContextMenuInteractionObs => _willEndContextMenuInteraction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator)> WillPerformPreviewActionObs => _willPerformPreviewAction; + /// + public override void AccessoryButtonTapped(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath) => _accessoryButtonTapped.OnNext((tableView, indexPath)); + /// + public override void CellDisplayingEnded(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath) => _cellDisplayingEnded.OnNext((tableView, cell, indexPath)); + /// + public override void DidBeginMultipleSelectionInteraction(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath) => _didBeginMultipleSelectionInteraction.OnNext((tableView, indexPath)); + /// + public override void DidEndEditing(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath) => _didEndEditing.OnNext((tableView, indexPath)); + /// + public override void DidEndMultipleSelectionInteraction(global::UIKit.UITableView tableView) => _didEndMultipleSelectionInteraction.OnNext(tableView); + /// + public override void DidUpdateFocus(global::UIKit.UITableView tableView, global::UIKit.UITableViewFocusUpdateContext context, global::UIKit.UIFocusAnimationCoordinator coordinator) => _didUpdateFocus.OnNext((tableView, context, coordinator)); + /// + public override void FooterViewDisplayingEnded(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section) => _footerViewDisplayingEnded.OnNext((tableView, footerView, section)); + /// + public override void HeaderViewDisplayingEnded(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section) => _headerViewDisplayingEnded.OnNext((tableView, headerView, section)); + /// + public override void PerformAction(global::UIKit.UITableView tableView, global::ObjCRuntime.Selector action, global::Foundation.NSIndexPath indexPath, global::Foundation.NSObject sender) => _performAction.OnNext((tableView, action, indexPath, sender)); + /// + public override void RowDeselected(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath) => _rowDeselected.OnNext((tableView, indexPath)); + /// + public override void RowHighlighted(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath) => _rowHighlighted.OnNext((tableView, rowIndexPath)); + /// + public override void RowSelected(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath) => _rowSelected.OnNext((tableView, indexPath)); + /// + public override void RowUnhighlighted(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath) => _rowUnhighlighted.OnNext((tableView, rowIndexPath)); + /// + public override void WillBeginEditing(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath) => _willBeginEditing.OnNext((tableView, indexPath)); + /// + public override void WillDisplay(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath) => _willDisplay.OnNext((tableView, cell, indexPath)); + /// + public override void WillDisplayContextMenu(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator) => _willDisplayContextMenu.OnNext((tableView, configuration, animator)); + /// + public override void WillDisplayFooterView(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section) => _willDisplayFooterView.OnNext((tableView, footerView, section)); + /// + public override void WillDisplayHeaderView(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section) => _willDisplayHeaderView.OnNext((tableView, headerView, section)); + /// + public override void WillEndContextMenuInteraction(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator) => _willEndContextMenuInteraction.OnNext((tableView, configuration, animator)); + /// + public override void WillPerformPreviewAction(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator) => _willPerformPreviewAction.OnNext((tableView, configuration, animator)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UITableViewDragDelegateRx : global::UIKit.UITableViewDragDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.IUIDragSession session)> _dragSessionDidEnd = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.IUIDragSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.IUIDragSession session)> _dragSessionWillBegin = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.IUIDragSession session)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.IUIDragSession session)> DragSessionDidEndObs => _dragSessionDidEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.IUIDragSession session)> DragSessionWillBeginObs => _dragSessionWillBegin; + /// + public override void DragSessionDidEnd(global::UIKit.UITableView tableView, global::UIKit.IUIDragSession session) => _dragSessionDidEnd.OnNext((tableView, session)); + /// + public override void DragSessionWillBegin(global::UIKit.UITableView tableView, global::UIKit.IUIDragSession session) => _dragSessionWillBegin.OnNext((tableView, session)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UITableViewDropDelegateRx : global::UIKit.UITableViewDropDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.IUIDropSession session)> _dropSessionDidEnd = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.IUIDropSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.IUIDropSession session)> _dropSessionDidEnter = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.IUIDropSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.IUIDropSession session)> _dropSessionDidExit = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.IUIDropSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.IUITableViewDropCoordinator coordinator)> _performDrop = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.IUITableViewDropCoordinator coordinator)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.IUIDropSession session)> DropSessionDidEndObs => _dropSessionDidEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.IUIDropSession session)> DropSessionDidEnterObs => _dropSessionDidEnter; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.IUIDropSession session)> DropSessionDidExitObs => _dropSessionDidExit; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.IUITableViewDropCoordinator coordinator)> PerformDropObs => _performDrop; + /// + public override void DropSessionDidEnd(global::UIKit.UITableView tableView, global::UIKit.IUIDropSession session) => _dropSessionDidEnd.OnNext((tableView, session)); + /// + public override void DropSessionDidEnter(global::UIKit.UITableView tableView, global::UIKit.IUIDropSession session) => _dropSessionDidEnter.OnNext((tableView, session)); + /// + public override void DropSessionDidExit(global::UIKit.UITableView tableView, global::UIKit.IUIDropSession session) => _dropSessionDidExit.OnNext((tableView, session)); + /// + public override void PerformDrop(global::UIKit.UITableView tableView, global::UIKit.IUITableViewDropCoordinator coordinator) => _performDrop.OnNext((tableView, coordinator)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UITableViewSourceRx : global::UIKit.UITableViewSource + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> _accessoryButtonTapped = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath)> _cellDisplayingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UITableViewCellEditingStyle editingStyle, global::Foundation.NSIndexPath indexPath)> _commitEditingStyle = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UITableViewCellEditingStyle editingStyle, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> _didBeginMultipleSelectionInteraction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> _didEndEditing = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEndMultipleSelectionInteraction = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UITableViewFocusUpdateContext context, global::UIKit.UIFocusAnimationCoordinator coordinator)> _didUpdateFocus = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UITableViewFocusUpdateContext context, global::UIKit.UIFocusAnimationCoordinator coordinator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section)> _footerViewDisplayingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section)> _headerViewDisplayingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath sourceIndexPath, global::Foundation.NSIndexPath destinationIndexPath)> _moveRow = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath sourceIndexPath, global::Foundation.NSIndexPath destinationIndexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::ObjCRuntime.Selector action, global::Foundation.NSIndexPath indexPath, global::Foundation.NSObject sender)> _performAction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::ObjCRuntime.Selector action, global::Foundation.NSIndexPath indexPath, global::Foundation.NSObject sender)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> _rowDeselected = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath)> _rowHighlighted = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> _rowSelected = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath)> _rowUnhighlighted = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> _willBeginEditing = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath)> _willDisplay = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> _willDisplayContextMenu = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section)> _willDisplayFooterView = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section)> _willDisplayHeaderView = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> _willEndContextMenuInteraction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator)> _willPerformPreviewAction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> AccessoryButtonTappedObs => _accessoryButtonTapped; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath)> CellDisplayingEndedObs => _cellDisplayingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UITableViewCellEditingStyle editingStyle, global::Foundation.NSIndexPath indexPath)> CommitEditingStyleObs => _commitEditingStyle; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> DidBeginMultipleSelectionInteractionObs => _didBeginMultipleSelectionInteraction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> DidEndEditingObs => _didEndEditing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndMultipleSelectionInteractionObs => _didEndMultipleSelectionInteraction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UITableViewFocusUpdateContext context, global::UIKit.UIFocusAnimationCoordinator coordinator)> DidUpdateFocusObs => _didUpdateFocus; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section)> FooterViewDisplayingEndedObs => _footerViewDisplayingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section)> HeaderViewDisplayingEndedObs => _headerViewDisplayingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath sourceIndexPath, global::Foundation.NSIndexPath destinationIndexPath)> MoveRowObs => _moveRow; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::ObjCRuntime.Selector action, global::Foundation.NSIndexPath indexPath, global::Foundation.NSObject sender)> PerformActionObs => _performAction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> RowDeselectedObs => _rowDeselected; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath)> RowHighlightedObs => _rowHighlighted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> RowSelectedObs => _rowSelected; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath)> RowUnhighlightedObs => _rowUnhighlighted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath)> WillBeginEditingObs => _willBeginEditing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath)> WillDisplayObs => _willDisplay; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> WillDisplayContextMenuObs => _willDisplayContextMenu; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section)> WillDisplayFooterViewObs => _willDisplayFooterView; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section)> WillDisplayHeaderViewObs => _willDisplayHeaderView; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator)> WillEndContextMenuInteractionObs => _willEndContextMenuInteraction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator)> WillPerformPreviewActionObs => _willPerformPreviewAction; + /// + public override void AccessoryButtonTapped(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath) => _accessoryButtonTapped.OnNext((tableView, indexPath)); + /// + public override void CellDisplayingEnded(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath) => _cellDisplayingEnded.OnNext((tableView, cell, indexPath)); + /// + public override void CommitEditingStyle(global::UIKit.UITableView tableView, global::UIKit.UITableViewCellEditingStyle editingStyle, global::Foundation.NSIndexPath indexPath) => _commitEditingStyle.OnNext((tableView, editingStyle, indexPath)); + /// + public override void DidBeginMultipleSelectionInteraction(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath) => _didBeginMultipleSelectionInteraction.OnNext((tableView, indexPath)); + /// + public override void DidEndEditing(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath) => _didEndEditing.OnNext((tableView, indexPath)); + /// + public override void DidEndMultipleSelectionInteraction(global::UIKit.UITableView tableView) => _didEndMultipleSelectionInteraction.OnNext(tableView); + /// + public override void DidUpdateFocus(global::UIKit.UITableView tableView, global::UIKit.UITableViewFocusUpdateContext context, global::UIKit.UIFocusAnimationCoordinator coordinator) => _didUpdateFocus.OnNext((tableView, context, coordinator)); + /// + public override void FooterViewDisplayingEnded(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section) => _footerViewDisplayingEnded.OnNext((tableView, footerView, section)); + /// + public override void HeaderViewDisplayingEnded(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section) => _headerViewDisplayingEnded.OnNext((tableView, headerView, section)); + /// + public override void MoveRow(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath sourceIndexPath, global::Foundation.NSIndexPath destinationIndexPath) => _moveRow.OnNext((tableView, sourceIndexPath, destinationIndexPath)); + /// + public override void PerformAction(global::UIKit.UITableView tableView, global::ObjCRuntime.Selector action, global::Foundation.NSIndexPath indexPath, global::Foundation.NSObject sender) => _performAction.OnNext((tableView, action, indexPath, sender)); + /// + public override void RowDeselected(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath) => _rowDeselected.OnNext((tableView, indexPath)); + /// + public override void RowHighlighted(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath) => _rowHighlighted.OnNext((tableView, rowIndexPath)); + /// + public override void RowSelected(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath) => _rowSelected.OnNext((tableView, indexPath)); + /// + public override void RowUnhighlighted(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath rowIndexPath) => _rowUnhighlighted.OnNext((tableView, rowIndexPath)); + /// + public override void WillBeginEditing(global::UIKit.UITableView tableView, global::Foundation.NSIndexPath indexPath) => _willBeginEditing.OnNext((tableView, indexPath)); + /// + public override void WillDisplay(global::UIKit.UITableView tableView, global::UIKit.UITableViewCell cell, global::Foundation.NSIndexPath indexPath) => _willDisplay.OnNext((tableView, cell, indexPath)); + /// + public override void WillDisplayContextMenu(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator) => _willDisplayContextMenu.OnNext((tableView, configuration, animator)); + /// + public override void WillDisplayFooterView(global::UIKit.UITableView tableView, global::UIKit.UIView footerView, global::System.nint section) => _willDisplayFooterView.OnNext((tableView, footerView, section)); + /// + public override void WillDisplayHeaderView(global::UIKit.UITableView tableView, global::UIKit.UIView headerView, global::System.nint section) => _willDisplayHeaderView.OnNext((tableView, headerView, section)); + /// + public override void WillEndContextMenuInteraction(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionAnimating animator) => _willEndContextMenuInteraction.OnNext((tableView, configuration, animator)); + /// + public override void WillPerformPreviewAction(global::UIKit.UITableView tableView, global::UIKit.UIContextMenuConfiguration configuration, global::UIKit.IUIContextMenuInteractionCommitAnimating animator) => _willPerformPreviewAction.OnNext((tableView, configuration, animator)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UITextDragDelegateRx : global::UIKit.UITextDragDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDraggable textDraggableView, global::UIKit.IUIDragSession session, global::UIKit.UIDropOperation operation)> _dragSessionDidEnd = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDraggable textDraggableView, global::UIKit.IUIDragSession session, global::UIKit.UIDropOperation operation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDraggable textDraggableView, global::UIKit.IUIDragSession session)> _dragSessionWillBegin = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDraggable textDraggableView, global::UIKit.IUIDragSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDraggable textDraggableView, global::UIKit.IUIDragAnimating animator, global::UIKit.IUIDragSession session)> _willAnimateLift = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDraggable textDraggableView, global::UIKit.IUIDragAnimating animator, global::UIKit.IUIDragSession session)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.IUITextDraggable textDraggableView, global::UIKit.IUIDragSession session, global::UIKit.UIDropOperation operation)> DragSessionDidEndObs => _dragSessionDidEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.IUITextDraggable textDraggableView, global::UIKit.IUIDragSession session)> DragSessionWillBeginObs => _dragSessionWillBegin; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.IUITextDraggable textDraggableView, global::UIKit.IUIDragAnimating animator, global::UIKit.IUIDragSession session)> WillAnimateLiftObs => _willAnimateLift; + /// + public override void DragSessionDidEnd(global::UIKit.IUITextDraggable textDraggableView, global::UIKit.IUIDragSession session, global::UIKit.UIDropOperation operation) => _dragSessionDidEnd.OnNext((textDraggableView, session, operation)); + /// + public override void DragSessionWillBegin(global::UIKit.IUITextDraggable textDraggableView, global::UIKit.IUIDragSession session) => _dragSessionWillBegin.OnNext((textDraggableView, session)); + /// + public override void WillAnimateLift(global::UIKit.IUITextDraggable textDraggableView, global::UIKit.IUIDragAnimating animator, global::UIKit.IUIDragSession session) => _willAnimateLift.OnNext((textDraggableView, animator, session)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UITextDropDelegateRx : global::UIKit.UITextDropDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session)> _dropSessionDidEnd = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session)> _dropSessionDidEnter = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session)> _dropSessionDidExit = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session)> _dropSessionDidUpdate = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUITextDropRequest drop)> _willPerformDrop = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUITextDropRequest drop)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session)> DropSessionDidEndObs => _dropSessionDidEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session)> DropSessionDidEnterObs => _dropSessionDidEnter; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session)> DropSessionDidExitObs => _dropSessionDidExit; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session)> DropSessionDidUpdateObs => _dropSessionDidUpdate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUITextDropRequest drop)> WillPerformDropObs => _willPerformDrop; + /// + public override void DropSessionDidEnd(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session) => _dropSessionDidEnd.OnNext((textDroppableView, session)); + /// + public override void DropSessionDidEnter(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session) => _dropSessionDidEnter.OnNext((textDroppableView, session)); + /// + public override void DropSessionDidExit(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session) => _dropSessionDidExit.OnNext((textDroppableView, session)); + /// + public override void DropSessionDidUpdate(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUIDropSession session) => _dropSessionDidUpdate.OnNext((textDroppableView, session)); + /// + public override void WillPerformDrop(global::UIKit.IUITextDroppable textDroppableView, global::UIKit.IUITextDropRequest drop) => _willPerformDrop.OnNext((textDroppableView, drop)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UITextFieldDelegateRx : global::UIKit.UITextFieldDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeSelection = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITextField textField, global::UIKit.UITextFieldDidEndEditingReason reason)> _editingEnded = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UITextField textField, global::UIKit.UITextFieldDidEndEditingReason reason)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _editingStarted = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeSelectionObs => _didChangeSelection; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UITextField textField, global::UIKit.UITextFieldDidEndEditingReason reason)> EditingEndedObs => _editingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable EditingStartedObs => _editingStarted; + /// + public override void DidChangeSelection(global::UIKit.UITextField textField) => _didChangeSelection.OnNext(textField); + /// + public override void EditingEnded(global::UIKit.UITextField textField, global::UIKit.UITextFieldDidEndEditingReason reason) => _editingEnded.OnNext((textField, reason)); + /// + public override void EditingStarted(global::UIKit.UITextField textField) => _editingStarted.OnNext(textField); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UITextFormattingCoordinatorDelegateRx : global::UIKit.UITextFormattingCoordinatorDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _updateTextAttributes = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UpdateTextAttributesObs => _updateTextAttributes; + /// + public override void UpdateTextAttributes(global::UIKit.UITextAttributesConversionHandler conversionHandler) => _updateTextAttributes.OnNext(conversionHandler); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UITextInputDelegateRx : global::UIKit.UITextInputDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _selectionDidChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _selectionWillChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _textDidChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _textWillChange = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SelectionDidChangeObs => _selectionDidChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SelectionWillChangeObs => _selectionWillChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable TextDidChangeObs => _textDidChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable TextWillChangeObs => _textWillChange; + /// + public override void SelectionDidChange(global::UIKit.IUITextInput uiTextInput) => _selectionDidChange.OnNext(uiTextInput); + /// + public override void SelectionWillChange(global::UIKit.IUITextInput uiTextInput) => _selectionWillChange.OnNext(uiTextInput); + /// + public override void TextDidChange(global::UIKit.IUITextInput textInput) => _textDidChange.OnNext(textInput); + /// + public override void TextWillChange(global::UIKit.IUITextInput textInput) => _textWillChange.OnNext(textInput); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UITextInteractionDelegateRx : global::UIKit.UITextInteractionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didEnd = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willBegin = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndObs => _didEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillBeginObs => _willBegin; + /// + public override void DidEnd(global::UIKit.UITextInteraction interaction) => _didEnd.OnNext(interaction); + /// + public override void WillBegin(global::UIKit.UITextInteraction interaction) => _willBegin.OnNext(interaction); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UITextPasteDelegateRx : global::UIKit.UITextPasteDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextPasteConfigurationSupporting textPasteConfigurationSupporting, global::UIKit.IUITextPasteItem item)> _transformPasteItem = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUITextPasteConfigurationSupporting textPasteConfigurationSupporting, global::UIKit.IUITextPasteItem item)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.IUITextPasteConfigurationSupporting textPasteConfigurationSupporting, global::UIKit.IUITextPasteItem item)> TransformPasteItemObs => _transformPasteItem; + /// + public override void TransformPasteItem(global::UIKit.IUITextPasteConfigurationSupporting textPasteConfigurationSupporting, global::UIKit.IUITextPasteItem item) => _transformPasteItem.OnNext((textPasteConfigurationSupporting, item)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UITextViewDelegateRx : global::UIKit.UITextViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _changed = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _editingEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _editingStarted = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _selectionChanged = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ChangedObs => _changed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable EditingEndedObs => _editingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable EditingStartedObs => _editingStarted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SelectionChangedObs => _selectionChanged; + /// + public override void Changed(global::UIKit.UITextView textView) => _changed.OnNext(textView); + /// + public override void EditingEnded(global::UIKit.UITextView textView) => _editingEnded.OnNext(textView); + /// + public override void EditingStarted(global::UIKit.UITextView textView) => _editingStarted.OnNext(textView); + /// + public override void SelectionChanged(global::UIKit.UITextView textView) => _selectionChanged.OnNext(textView); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIVideoEditorControllerDelegateRx : global::UIKit.UIVideoEditorControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIVideoEditorController editor, global::Foundation.NSError error)> _failed = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIVideoEditorController editor, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _userCancelled = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIVideoEditorController editor, string editedVideoPath)> _videoSaved = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIVideoEditorController editor, string editedVideoPath)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIVideoEditorController editor, global::Foundation.NSError error)> FailedObs => _failed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UserCancelledObs => _userCancelled; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIVideoEditorController editor, string editedVideoPath)> VideoSavedObs => _videoSaved; + /// + public override void Failed(global::UIKit.UIVideoEditorController editor, global::Foundation.NSError error) => _failed.OnNext((editor, error)); + /// + public override void UserCancelled(global::UIKit.UIVideoEditorController editor) => _userCancelled.OnNext(editor); + /// + public override void VideoSaved(global::UIKit.UIVideoEditorController editor, string editedVideoPath) => _videoSaved.OnNext((editor, editedVideoPath)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class UIViewControllerPreviewingDelegateRx : global::UIKit.UIViewControllerPreviewingDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUIViewControllerPreviewing previewingContext, global::UIKit.UIViewController viewControllerToCommit)> _commitViewController = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.IUIViewControllerPreviewing previewingContext, global::UIKit.UIViewController viewControllerToCommit)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.IUIViewControllerPreviewing previewingContext, global::UIKit.UIViewController viewControllerToCommit)> CommitViewControllerObs => _commitViewController; + /// + public override void CommitViewController(global::UIKit.IUIViewControllerPreviewing previewingContext, global::UIKit.UIViewController viewControllerToCommit) => _commitViewController.OnNext((previewingContext, viewControllerToCommit)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIWebViewDelegateRx : global::UIKit.UIWebViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIWebView webView, global::Foundation.NSError error)> _loadFailed = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIWebView webView, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _loadingFinished = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _loadStarted = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIWebView webView, global::Foundation.NSError error)> LoadFailedObs => _loadFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LoadingFinishedObs => _loadingFinished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LoadStartedObs => _loadStarted; + /// + public override void LoadFailed(global::UIKit.UIWebView webView, global::Foundation.NSError error) => _loadFailed.OnNext((webView, error)); + /// + public override void LoadingFinished(global::UIKit.UIWebView webView) => _loadingFinished.OnNext(webView); + /// + public override void LoadStarted(global::UIKit.UIWebView webView) => _loadStarted.OnNext(webView); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class UIWindowSceneDelegateRx : global::UIKit.UIWindowSceneDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> _continueUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeActive = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didDisconnect = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEnterBackground = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error)> _didFailToContinueUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIWindowScene windowScene, global::UIKit.IUICoordinateSpace previousCoordinateSpace, global::UIKit.UIInterfaceOrientation previousInterfaceOrientation, global::UIKit.UITraitCollection previousTraitCollection)> _didUpdateCoordinateSpace = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIWindowScene windowScene, global::UIKit.IUICoordinateSpace previousCoordinateSpace, global::UIKit.UIInterfaceOrientation previousInterfaceOrientation, global::UIKit.UITraitCollection previousTraitCollection)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> _didUpdateUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts)> _openUrlContexts = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIWindowScene windowScene, global::UIKit.UIApplicationShortcutItem shortcutItem, global::System.Action completionHandler)> _performAction = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIWindowScene windowScene, global::UIKit.UIApplicationShortcutItem shortcutItem, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIWindowScene windowScene, global::CloudKit.CKShareMetadata cloudKitShareMetadata)> _userDidAcceptCloudKitShare = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIWindowScene windowScene, global::CloudKit.CKShareMetadata cloudKitShareMetadata)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions)> _willConnect = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType)> _willContinueUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::UIKit.UIScene scene, string userActivityType)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willEnterForeground = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willResignActive = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> ContinueUserActivityObs => _continueUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeActiveObs => _didBecomeActive; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDisconnectObs => _didDisconnect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEnterBackgroundObs => _didEnterBackground; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error)> DidFailToContinueUserActivityObs => _didFailToContinueUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIWindowScene windowScene, global::UIKit.IUICoordinateSpace previousCoordinateSpace, global::UIKit.UIInterfaceOrientation previousInterfaceOrientation, global::UIKit.UITraitCollection previousTraitCollection)> DidUpdateCoordinateSpaceObs => _didUpdateCoordinateSpace; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity)> DidUpdateUserActivityObs => _didUpdateUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts)> OpenUrlContextsObs => _openUrlContexts; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIWindowScene windowScene, global::UIKit.UIApplicationShortcutItem shortcutItem, global::System.Action completionHandler)> PerformActionObs => _performAction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIWindowScene windowScene, global::CloudKit.CKShareMetadata cloudKitShareMetadata)> UserDidAcceptCloudKitShareObs => _userDidAcceptCloudKitShare; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions)> WillConnectObs => _willConnect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UIKit.UIScene scene, string userActivityType)> WillContinueUserActivityObs => _willContinueUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillEnterForegroundObs => _willEnterForeground; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillResignActiveObs => _willResignActive; + /// + public override void ContinueUserActivity(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity) => _continueUserActivity.OnNext((scene, userActivity)); + /// + public override void DidBecomeActive(global::UIKit.UIScene scene) => _didBecomeActive.OnNext(scene); + /// + public override void DidDisconnect(global::UIKit.UIScene scene) => _didDisconnect.OnNext(scene); + /// + public override void DidEnterBackground(global::UIKit.UIScene scene) => _didEnterBackground.OnNext(scene); + /// + public override void DidFailToContinueUserActivity(global::UIKit.UIScene scene, string userActivityType, global::Foundation.NSError error) => _didFailToContinueUserActivity.OnNext((scene, userActivityType, error)); + /// + public override void DidUpdateCoordinateSpace(global::UIKit.UIWindowScene windowScene, global::UIKit.IUICoordinateSpace previousCoordinateSpace, global::UIKit.UIInterfaceOrientation previousInterfaceOrientation, global::UIKit.UITraitCollection previousTraitCollection) => _didUpdateCoordinateSpace.OnNext((windowScene, previousCoordinateSpace, previousInterfaceOrientation, previousTraitCollection)); + /// + public override void DidUpdateUserActivity(global::UIKit.UIScene scene, global::Foundation.NSUserActivity userActivity) => _didUpdateUserActivity.OnNext((scene, userActivity)); + /// + public override void OpenUrlContexts(global::UIKit.UIScene scene, global::Foundation.NSSet urlContexts) => _openUrlContexts.OnNext((scene, urlContexts)); + /// + public override void PerformAction(global::UIKit.UIWindowScene windowScene, global::UIKit.UIApplicationShortcutItem shortcutItem, global::System.Action completionHandler) => _performAction.OnNext((windowScene, shortcutItem, completionHandler)); + /// + public override void UserDidAcceptCloudKitShare(global::UIKit.UIWindowScene windowScene, global::CloudKit.CKShareMetadata cloudKitShareMetadata) => _userDidAcceptCloudKitShare.OnNext((windowScene, cloudKitShareMetadata)); + /// + public override void WillConnect(global::UIKit.UIScene scene, global::UIKit.UISceneSession session, global::UIKit.UISceneConnectionOptions connectionOptions) => _willConnect.OnNext((scene, session, connectionOptions)); + /// + public override void WillContinueUserActivity(global::UIKit.UIScene scene, string userActivityType) => _willContinueUserActivity.OnNext((scene, userActivityType)); + /// + public override void WillEnterForeground(global::UIKit.UIScene scene) => _willEnterForeground.OnNext(scene); + /// + public override void WillResignActive(global::UIKit.UIScene scene) => _willResignActive.OnNext(scene); + } +} + +namespace UserNotifications +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class UNUserNotificationCenterDelegateRx : global::UserNotifications.UNUserNotificationCenterDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotificationResponse response, global::System.Action completionHandler)> _didReceiveNotificationResponse = new Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotificationResponse response, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification)> _openSettings = new Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification, global::System.Action completionHandler)> _willPresentNotification = new Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotificationResponse response, global::System.Action completionHandler)> DidReceiveNotificationResponseObs => _didReceiveNotificationResponse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification)> OpenSettingsObs => _openSettings; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification, global::System.Action completionHandler)> WillPresentNotificationObs => _willPresentNotification; + /// + public override void DidReceiveNotificationResponse(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotificationResponse response, global::System.Action completionHandler) => _didReceiveNotificationResponse.OnNext((center, response, completionHandler)); + /// + public override void OpenSettings(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification) => _openSettings.OnNext((center, notification)); + /// + public override void WillPresentNotification(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification, global::System.Action completionHandler) => _willPresentNotification.OnNext((center, notification, completionHandler)); + } +} + +namespace VideoSubscriberAccount +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class VSAccountManagerDelegateRx : global::VideoSubscriberAccount.VSAccountManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::VideoSubscriberAccount.VSAccountManager accountManager, global::UIKit.UIViewController viewController)> _dismissViewController = new Pharmacist.Common.SingleAwaitSubject<(global::VideoSubscriberAccount.VSAccountManager accountManager, global::UIKit.UIViewController viewController)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::VideoSubscriberAccount.VSAccountManager accountManager, global::UIKit.UIViewController viewController)> _presentViewController = new Pharmacist.Common.SingleAwaitSubject<(global::VideoSubscriberAccount.VSAccountManager accountManager, global::UIKit.UIViewController viewController)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::VideoSubscriberAccount.VSAccountManager accountManager, global::UIKit.UIViewController viewController)> DismissViewControllerObs => _dismissViewController; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::VideoSubscriberAccount.VSAccountManager accountManager, global::UIKit.UIViewController viewController)> PresentViewControllerObs => _presentViewController; + /// + public override void DismissViewController(global::VideoSubscriberAccount.VSAccountManager accountManager, global::UIKit.UIViewController viewController) => _dismissViewController.OnNext((accountManager, viewController)); + /// + public override void PresentViewController(global::VideoSubscriberAccount.VSAccountManager accountManager, global::UIKit.UIViewController viewController) => _presentViewController.OnNext((accountManager, viewController)); + } +} + +namespace VisionKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class VNDocumentCameraViewControllerDelegateRx : global::VisionKit.VNDocumentCameraViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didCancel = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::VisionKit.VNDocumentCameraViewController controller, global::Foundation.NSError error)> _didFail = new Pharmacist.Common.SingleAwaitSubject<(global::VisionKit.VNDocumentCameraViewController controller, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::VisionKit.VNDocumentCameraViewController controller, global::VisionKit.VNDocumentCameraScan scan)> _didFinish = new Pharmacist.Common.SingleAwaitSubject<(global::VisionKit.VNDocumentCameraViewController controller, global::VisionKit.VNDocumentCameraScan scan)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidCancelObs => _didCancel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::VisionKit.VNDocumentCameraViewController controller, global::Foundation.NSError error)> DidFailObs => _didFail; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::VisionKit.VNDocumentCameraViewController controller, global::VisionKit.VNDocumentCameraScan scan)> DidFinishObs => _didFinish; + /// + public override void DidCancel(global::VisionKit.VNDocumentCameraViewController controller) => _didCancel.OnNext(controller); + /// + public override void DidFail(global::VisionKit.VNDocumentCameraViewController controller, global::Foundation.NSError error) => _didFail.OnNext((controller, error)); + /// + public override void DidFinish(global::VisionKit.VNDocumentCameraViewController controller, global::VisionKit.VNDocumentCameraScan scan) => _didFinish.OnNext((controller, scan)); + } +} + +namespace WatchConnectivity +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class WCSessionDelegateRx : global::WatchConnectivity.WCSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionActivationState activationState, global::Foundation.NSError error)> _activationDidComplete = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionActivationState activationState, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeInactive = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didDeactivate = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFileTransfer fileTransfer, global::Foundation.NSError error)> _didFinishFileTransfer = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFileTransfer fileTransfer, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionUserInfoTransfer userInfoTransfer, global::Foundation.NSError error)> _didFinishUserInfoTransfer = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionUserInfoTransfer userInfoTransfer, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary applicationContext)> _didReceiveApplicationContext = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary applicationContext)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFile file)> _didReceiveFile = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFile file)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary message, global::WatchConnectivity.WCSessionReplyHandler replyHandler)> _didReceiveMessage = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary message, global::WatchConnectivity.WCSessionReplyHandler replyHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSData messageData, global::WatchConnectivity.WCSessionReplyDataHandler replyHandler)> _didReceiveMessageData = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSData messageData, global::WatchConnectivity.WCSessionReplyDataHandler replyHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary userInfo)> _didReceiveUserInfo = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary userInfo)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _sessionReachabilityDidChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _sessionWatchStateDidChange = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionActivationState activationState, global::Foundation.NSError error)> ActivationDidCompleteObs => _activationDidComplete; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeInactiveObs => _didBecomeInactive; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDeactivateObs => _didDeactivate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFileTransfer fileTransfer, global::Foundation.NSError error)> DidFinishFileTransferObs => _didFinishFileTransfer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionUserInfoTransfer userInfoTransfer, global::Foundation.NSError error)> DidFinishUserInfoTransferObs => _didFinishUserInfoTransfer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary applicationContext)> DidReceiveApplicationContextObs => _didReceiveApplicationContext; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFile file)> DidReceiveFileObs => _didReceiveFile; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary message, global::WatchConnectivity.WCSessionReplyHandler replyHandler)> DidReceiveMessageObs => _didReceiveMessage; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::Foundation.NSData messageData, global::WatchConnectivity.WCSessionReplyDataHandler replyHandler)> DidReceiveMessageDataObs => _didReceiveMessageData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary userInfo)> DidReceiveUserInfoObs => _didReceiveUserInfo; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SessionReachabilityDidChangeObs => _sessionReachabilityDidChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SessionWatchStateDidChangeObs => _sessionWatchStateDidChange; + /// + public override void ActivationDidComplete(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionActivationState activationState, global::Foundation.NSError error) => _activationDidComplete.OnNext((session, activationState, error)); + /// + public override void DidBecomeInactive(global::WatchConnectivity.WCSession session) => _didBecomeInactive.OnNext(session); + /// + public override void DidDeactivate(global::WatchConnectivity.WCSession session) => _didDeactivate.OnNext(session); + /// + public override void DidFinishFileTransfer(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFileTransfer fileTransfer, global::Foundation.NSError error) => _didFinishFileTransfer.OnNext((session, fileTransfer, error)); + /// + public override void DidFinishUserInfoTransfer(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionUserInfoTransfer userInfoTransfer, global::Foundation.NSError error) => _didFinishUserInfoTransfer.OnNext((session, userInfoTransfer, error)); + /// + public override void DidReceiveApplicationContext(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary applicationContext) => _didReceiveApplicationContext.OnNext((session, applicationContext)); + /// + public override void DidReceiveFile(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFile file) => _didReceiveFile.OnNext((session, file)); + /// + public override void DidReceiveMessage(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary message, global::WatchConnectivity.WCSessionReplyHandler replyHandler) => _didReceiveMessage.OnNext((session, message, replyHandler)); + /// + public override void DidReceiveMessageData(global::WatchConnectivity.WCSession session, global::Foundation.NSData messageData, global::WatchConnectivity.WCSessionReplyDataHandler replyHandler) => _didReceiveMessageData.OnNext((session, messageData, replyHandler)); + /// + public override void DidReceiveUserInfo(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary userInfo) => _didReceiveUserInfo.OnNext((session, userInfo)); + /// + public override void SessionReachabilityDidChange(global::WatchConnectivity.WCSession session) => _sessionReachabilityDidChange.OnNext(session); + /// + public override void SessionWatchStateDidChange(global::WatchConnectivity.WCSession session) => _sessionWatchStateDidChange.OnNext(session); + } +} + +namespace WebKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class WKNavigationDelegateRx : global::WebKit.WKNavigationDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _contentProcessDidTerminate = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigationAction navigationAction, global::WebKit.WKWebpagePreferences preferences, global::System.Action decisionHandler)> _decidePolicy = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigationAction navigationAction, global::WebKit.WKWebpagePreferences preferences, global::System.Action decisionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> _didCommitNavigation = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error)> _didFailNavigation = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error)> _didFailProvisionalNavigation = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> _didFinishNavigation = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> _didReceiveAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> _didReceiveServerRedirectForProvisionalNavigation = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> _didStartProvisionalNavigation = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action decisionHandler)> _shouldAllowDeprecatedTls = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action decisionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ContentProcessDidTerminateObs => _contentProcessDidTerminate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKNavigationAction navigationAction, global::WebKit.WKWebpagePreferences preferences, global::System.Action decisionHandler)> DecidePolicyObs => _decidePolicy; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> DidCommitNavigationObs => _didCommitNavigation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error)> DidFailNavigationObs => _didFailNavigation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error)> DidFailProvisionalNavigationObs => _didFailProvisionalNavigation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> DidFinishNavigationObs => _didFinishNavigation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> DidReceiveAuthenticationChallengeObs => _didReceiveAuthenticationChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> DidReceiveServerRedirectForProvisionalNavigationObs => _didReceiveServerRedirectForProvisionalNavigation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> DidStartProvisionalNavigationObs => _didStartProvisionalNavigation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action decisionHandler)> ShouldAllowDeprecatedTlsObs => _shouldAllowDeprecatedTls; + /// + public override void ContentProcessDidTerminate(global::WebKit.WKWebView webView) => _contentProcessDidTerminate.OnNext(webView); + /// + public override void DecidePolicy(global::WebKit.WKWebView webView, global::WebKit.WKNavigationAction navigationAction, global::WebKit.WKWebpagePreferences preferences, global::System.Action decisionHandler) => _decidePolicy.OnNext((webView, navigationAction, preferences, decisionHandler)); + /// + public override void DidCommitNavigation(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation) => _didCommitNavigation.OnNext((webView, navigation)); + /// + public override void DidFailNavigation(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error) => _didFailNavigation.OnNext((webView, navigation, error)); + /// + public override void DidFailProvisionalNavigation(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error) => _didFailProvisionalNavigation.OnNext((webView, navigation, error)); + /// + public override void DidFinishNavigation(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation) => _didFinishNavigation.OnNext((webView, navigation)); + /// + public override void DidReceiveAuthenticationChallenge(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler) => _didReceiveAuthenticationChallenge.OnNext((webView, challenge, completionHandler)); + /// + public override void DidReceiveServerRedirectForProvisionalNavigation(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation) => _didReceiveServerRedirectForProvisionalNavigation.OnNext((webView, navigation)); + /// + public override void DidStartProvisionalNavigation(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation) => _didStartProvisionalNavigation.OnNext((webView, navigation)); + /// + public override void ShouldAllowDeprecatedTls(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action decisionHandler) => _shouldAllowDeprecatedTls.OnNext((webView, challenge, decisionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class WKUIDelegateRx : global::WebKit.WKUIDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::UIKit.UIViewController previewingViewController)> _commitPreviewingViewController = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::UIKit.UIViewController previewingViewController)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo)> _contextMenuDidEnd = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo)> _contextMenuWillPresent = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didClose = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)> _runJavaScriptAlertPanel = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)> _runJavaScriptConfirmPanel = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, string prompt, string defaultText, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)> _runJavaScriptTextInputPanel = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, string prompt, string defaultText, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo, global::System.Action completionHandler)> _setContextMenuConfiguration = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo, global::UIKit.IUIContextMenuInteractionCommitAnimating animator)> _willCommitContextMenu = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo, global::UIKit.IUIContextMenuInteractionCommitAnimating animator)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::UIKit.UIViewController previewingViewController)> CommitPreviewingViewControllerObs => _commitPreviewingViewController; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo)> ContextMenuDidEndObs => _contextMenuDidEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo)> ContextMenuWillPresentObs => _contextMenuWillPresent; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidCloseObs => _didClose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)> RunJavaScriptAlertPanelObs => _runJavaScriptAlertPanel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)> RunJavaScriptConfirmPanelObs => _runJavaScriptConfirmPanel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, string prompt, string defaultText, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)> RunJavaScriptTextInputPanelObs => _runJavaScriptTextInputPanel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo, global::System.Action completionHandler)> SetContextMenuConfigurationObs => _setContextMenuConfiguration; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo, global::UIKit.IUIContextMenuInteractionCommitAnimating animator)> WillCommitContextMenuObs => _willCommitContextMenu; + /// + public override void CommitPreviewingViewController(global::WebKit.WKWebView webView, global::UIKit.UIViewController previewingViewController) => _commitPreviewingViewController.OnNext((webView, previewingViewController)); + /// + public override void ContextMenuDidEnd(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo) => _contextMenuDidEnd.OnNext((webView, elementInfo)); + /// + public override void ContextMenuWillPresent(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo) => _contextMenuWillPresent.OnNext((webView, elementInfo)); + /// + public override void DidClose(global::WebKit.WKWebView webView) => _didClose.OnNext(webView); + /// + public override void RunJavaScriptAlertPanel(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler) => _runJavaScriptAlertPanel.OnNext((webView, message, frame, completionHandler)); + /// + public override void RunJavaScriptConfirmPanel(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler) => _runJavaScriptConfirmPanel.OnNext((webView, message, frame, completionHandler)); + /// + public override void RunJavaScriptTextInputPanel(global::WebKit.WKWebView webView, string prompt, string defaultText, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler) => _runJavaScriptTextInputPanel.OnNext((webView, prompt, defaultText, frame, completionHandler)); + /// + public override void SetContextMenuConfiguration(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo, global::System.Action completionHandler) => _setContextMenuConfiguration.OnNext((webView, elementInfo, completionHandler)); + /// + public override void WillCommitContextMenu(global::WebKit.WKWebView webView, global::WebKit.WKContextMenuElementInfo elementInfo, global::UIKit.IUIContextMenuInteractionCommitAnimating animator) => _willCommitContextMenu.OnNext((webView, elementInfo, animator)); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/xamarin.mac20.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/xamarin.mac20.approved.txt new file mode 100644 index 0000000..952e01c --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/xamarin.mac20.approved.txt @@ -0,0 +1,11896 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace AppKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSActionCellEvents Events(this global::AppKit.NSActionCell item) => new RxNSActionCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSAnimationEvents Events(this global::AppKit.NSAnimation item) => new RxNSAnimationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSApplicationEvents Events(this global::AppKit.NSApplication item) => new RxNSApplicationEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSBrowserEvents Events(this global::AppKit.NSBrowser item) => new RxNSBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSColorPickerTouchBarItemEvents Events(this global::AppKit.NSColorPickerTouchBarItem item) => new RxNSColorPickerTouchBarItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSComboBoxEvents Events(this global::AppKit.NSComboBox item) => new RxNSComboBoxEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSControlEvents Events(this global::AppKit.NSControl item) => new RxNSControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSDatePickerEvents Events(this global::AppKit.NSDatePicker item) => new RxNSDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSDatePickerCellEvents Events(this global::AppKit.NSDatePickerCell item) => new RxNSDatePickerCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSDrawerEvents Events(this global::AppKit.NSDrawer item) => new RxNSDrawerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSImageEvents Events(this global::AppKit.NSImage item) => new RxNSImageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSMatrixEvents Events(this global::AppKit.NSMatrix item) => new RxNSMatrixEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSMenuItemEvents Events(this global::AppKit.NSMenuItem item) => new RxNSMenuItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSPageControllerEvents Events(this global::AppKit.NSPageController item) => new RxNSPageControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSPathCellEvents Events(this global::AppKit.NSPathCell item) => new RxNSPathCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSPathControlEvents Events(this global::AppKit.NSPathControl item) => new RxNSPathControlEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSRuleEditorEvents Events(this global::AppKit.NSRuleEditor item) => new RxNSRuleEditorEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSSavePanelEvents Events(this global::AppKit.NSSavePanel item) => new RxNSSavePanelEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSSearchFieldEvents Events(this global::AppKit.NSSearchField item) => new RxNSSearchFieldEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSSharingServiceEvents Events(this global::AppKit.NSSharingService item) => new RxNSSharingServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSSharingServicePickerEvents Events(this global::AppKit.NSSharingServicePicker item) => new RxNSSharingServicePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSSliderTouchBarItemEvents Events(this global::AppKit.NSSliderTouchBarItem item) => new RxNSSliderTouchBarItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSSoundEvents Events(this global::AppKit.NSSound item) => new RxNSSoundEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSStatusItemEvents Events(this global::AppKit.NSStatusItem item) => new RxNSStatusItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSTableViewEvents Events(this global::AppKit.NSTableView item) => new RxNSTableViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSTabViewEvents Events(this global::AppKit.NSTabView item) => new RxNSTabViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSTextEvents Events(this global::AppKit.NSText item) => new RxNSTextEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSTextFieldEvents Events(this global::AppKit.NSTextField item) => new RxNSTextFieldEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSTextStorageEvents Events(this global::AppKit.NSTextStorage item) => new RxNSTextStorageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSTextViewEvents Events(this global::AppKit.NSTextView item) => new RxNSTextViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSToolbarEvents Events(this global::AppKit.NSToolbar item) => new RxNSToolbarEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSToolbarItemEvents Events(this global::AppKit.NSToolbarItem item) => new RxNSToolbarItemEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSWindowEvents Events(this global::AppKit.NSWindow item) => new RxNSWindowEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSActionCellEvents + { + private readonly global::AppKit.NSActionCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSActionCellEvents(global::AppKit.NSActionCell data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSAnimationEvents + { + private readonly global::AppKit.NSAnimation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSAnimationEvents(global::AppKit.NSAnimation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnimationDidEnd => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnimationDidEnd += x, x => _data.AnimationDidEnd -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnimationDidReachProgressMark => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSAnimationEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSAnimationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnimationDidReachProgressMark += x, x => _data.AnimationDidReachProgressMark -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnimationDidStop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnimationDidStop += x, x => _data.AnimationDidStop -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSApplicationEvents + { + private readonly global::AppKit.NSApplication _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSApplicationEvents(global::AppKit.NSApplication data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecodedRestorableState => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSCoderEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSCoderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecodedRestorableState += x, x => _data.DecodedRestorableState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidBecomeActive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidBecomeActive += x, x => _data.DidBecomeActive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinishLaunching => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinishLaunching += x, x => _data.DidFinishLaunching -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidHide => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidHide += x, x => _data.DidHide -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidResignActive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidResignActive += x, x => _data.DidResignActive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUnhide => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUnhide += x, x => _data.DidUnhide -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdate += x, x => _data.DidUpdate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FailedToContinueUserActivity => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSApplicationFailedEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSApplicationFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FailedToContinueUserActivity += x, x => _data.FailedToContinueUserActivity -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FailedToRegisterForRemoteNotifications => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FailedToRegisterForRemoteNotifications += x, x => _data.FailedToRegisterForRemoteNotifications -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OpenFiles => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSApplicationFilesEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSApplicationFilesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OpenFiles += x, x => _data.OpenFiles -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OpenUrls => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSApplicationOpenUrlsEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSApplicationOpenUrlsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OpenUrls += x, x => _data.OpenUrls -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + [global::System.ObsoleteAttribute("Use the 'OrderFrontStandardAboutPanel2' on NSApplication.", false)] + public global::System.IObservable OrderFrontStandardAboutPanel => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OrderFrontStandardAboutPanel += x, x => _data.OrderFrontStandardAboutPanel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + [global::System.ObsoleteAttribute("Use the 'OrderFrontStandardAboutPanelWithOptions2' on NSApplication.", false)] + public global::System.IObservable OrderFrontStandardAboutPanelWithOptions => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OrderFrontStandardAboutPanelWithOptions += x, x => _data.OrderFrontStandardAboutPanelWithOptions -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReceivedRemoteNotification => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSDictionaryEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSDictionaryEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReceivedRemoteNotification += x, x => _data.ReceivedRemoteNotification -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegisteredForRemoteNotifications => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSDataEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSDataEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegisteredForRemoteNotifications += x, x => _data.RegisteredForRemoteNotifications -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + [global::System.ObsoleteAttribute("Use the 'RegisterServicesMenu2' on NSApplication.", false)] + public global::System.IObservable RegisterServicesMenu => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSApplicationRegisterEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSApplicationRegisterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegisterServicesMenu += x, x => _data.RegisterServicesMenu -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScreenParametersChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScreenParametersChanged += x, x => _data.ScreenParametersChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedUserActivity => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSApplicationUpdatedUserActivityEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSApplicationUpdatedUserActivityEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedUserActivity += x, x => _data.UpdatedUserActivity -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UserDidAcceptCloudKitShare => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSApplicationUserAcceptedCloudKitShareEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSApplicationUserAcceptedCloudKitShareEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UserDidAcceptCloudKitShare += x, x => _data.UserDidAcceptCloudKitShare -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillBecomeActive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillBecomeActive += x, x => _data.WillBecomeActive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillEncodeRestorableState => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSCoderEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSCoderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillEncodeRestorableState += x, x => _data.WillEncodeRestorableState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillFinishLaunching => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillFinishLaunching += x, x => _data.WillFinishLaunching -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillHide => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillHide += x, x => _data.WillHide -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillResignActive => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillResignActive += x, x => _data.WillResignActive -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillTerminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillTerminate += x, x => _data.WillTerminate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillUnhide => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillUnhide += x, x => _data.WillUnhide -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillUpdate += x, x => _data.WillUpdate -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSBrowserEvents : global::AppKit.RxNSControlEvents + { + private readonly global::AppKit.NSBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSBrowserEvents(global::AppKit.NSBrowser data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSColorPickerTouchBarItemEvents + { + private readonly global::AppKit.NSColorPickerTouchBarItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSColorPickerTouchBarItemEvents(global::AppKit.NSColorPickerTouchBarItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSComboBoxEvents : global::AppKit.RxNSTextFieldEvents + { + private readonly global::AppKit.NSComboBox _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSComboBoxEvents(global::AppKit.NSComboBox data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionIsChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionIsChanging += x, x => _data.SelectionIsChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillDismiss => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillDismiss += x, x => _data.WillDismiss -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillPopUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillPopUp += x, x => _data.WillPopUp -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSControlEvents + { + private readonly global::AppKit.NSControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSControlEvents(global::AppKit.NSControl data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSDatePickerEvents : global::AppKit.RxNSControlEvents + { + private readonly global::AppKit.NSDatePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSDatePickerEvents(global::AppKit.NSDatePicker data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValidateProposedDateValue => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSDatePickerValidatorEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSDatePickerValidatorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValidateProposedDateValue += x, x => _data.ValidateProposedDateValue -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSDatePickerCellEvents : global::AppKit.RxNSActionCellEvents + { + private readonly global::AppKit.NSDatePickerCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSDatePickerCellEvents(global::AppKit.NSDatePickerCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ValidateProposedDateValue => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSDatePickerValidatorEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSDatePickerValidatorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ValidateProposedDateValue += x, x => _data.ValidateProposedDateValue -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSDrawerEvents + { + private readonly global::AppKit.NSDrawer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSDrawerEvents(global::AppKit.NSDrawer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawerDidClose => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawerDidClose += x, x => _data.DrawerDidClose -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawerDidOpen => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawerDidOpen += x, x => _data.DrawerDidOpen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawerWillClose => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawerWillClose += x, x => _data.DrawerWillClose -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawerWillOpen => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawerWillOpen += x, x => _data.DrawerWillOpen -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSImageEvents + { + private readonly global::AppKit.NSImage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSImageEvents(global::AppKit.NSImage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidLoadPartOfRepresentation => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSImagePartialEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSImagePartialEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidLoadPartOfRepresentation += x, x => _data.DidLoadPartOfRepresentation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidLoadRepresentation => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSImageLoadRepresentationEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSImageLoadRepresentationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidLoadRepresentation += x, x => _data.DidLoadRepresentation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidLoadRepresentationHeader => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSImageLoadEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSImageLoadEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidLoadRepresentationHeader += x, x => _data.DidLoadRepresentationHeader -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillLoadRepresentation => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSImageLoadEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSImageLoadEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillLoadRepresentation += x, x => _data.WillLoadRepresentation -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSMatrixEvents : global::AppKit.RxNSControlEvents + { + private readonly global::AppKit.NSMatrix _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSMatrixEvents(global::AppKit.NSMatrix data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSMenuItemEvents + { + private readonly global::AppKit.NSMenuItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSMenuItemEvents(global::AppKit.NSMenuItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSPageControllerEvents + { + private readonly global::AppKit.NSPageController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSPageControllerEvents(global::AppKit.NSPageController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEndLiveTransition => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEndLiveTransition += x, x => _data.DidEndLiveTransition -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidTransition => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPageControllerTransitionEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSPageControllerTransitionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidTransition += x, x => _data.DidTransition -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PrepareViewController => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPageControllerPrepareViewControllerEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSPageControllerPrepareViewControllerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PrepareViewController += x, x => _data.PrepareViewController -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillStartLiveTransition => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillStartLiveTransition += x, x => _data.WillStartLiveTransition -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSPathCellEvents : global::AppKit.RxNSActionCellEvents + { + private readonly global::AppKit.NSPathCell _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSPathCellEvents(global::AppKit.NSPathCell data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillDisplayOpenPanel => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPathCellDisplayPanelEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSPathCellDisplayPanelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillDisplayOpenPanel += x, x => _data.WillDisplayOpenPanel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillPopupMenu => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPathCellMenuEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSPathCellMenuEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillPopupMenu += x, x => _data.WillPopupMenu -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSPathControlEvents : global::AppKit.RxNSControlEvents + { + private readonly global::AppKit.NSPathControl _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSPathControlEvents(global::AppKit.NSPathControl data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSRuleEditorEvents : global::AppKit.RxNSControlEvents + { + private readonly global::AppKit.NSRuleEditor _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSRuleEditorEvents(global::AppKit.NSRuleEditor data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingBegan => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingBegan += x, x => _data.EditingBegan -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingEnded += x, x => _data.EditingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RowsDidChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RowsDidChange += x, x => _data.RowsDidChange -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSSavePanelEvents : global::AppKit.RxNSWindowEvents + { + private readonly global::AppKit.NSSavePanel _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSSavePanelEvents(global::AppKit.NSSavePanel data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidChangeToDirectory => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSOpenSavePanelUrlEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSOpenSavePanelUrlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidChangeToDirectory += x, x => _data.DidChangeToDirectory -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DirectoryDidChange => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSOpenSaveFilenameEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSOpenSaveFilenameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DirectoryDidChange += x, x => _data.DirectoryDidChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionDidChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionDidChange += x, x => _data.SelectionDidChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillExpand => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSOpenSaveExpandingEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSOpenSaveExpandingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillExpand += x, x => _data.WillExpand -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSSearchFieldEvents : global::AppKit.RxNSTextFieldEvents + { + private readonly global::AppKit.NSSearchField _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSSearchFieldEvents(global::AppKit.NSSearchField data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchingEnded += x, x => _data.SearchingEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchingStarted += x, x => _data.SearchingStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSSharingServiceEvents + { + private readonly global::AppKit.NSSharingService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSSharingServiceEvents(global::AppKit.NSSharingService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFailToShareItems => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSSharingServiceDidFailToShareItemsEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSSharingServiceDidFailToShareItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFailToShareItems += x, x => _data.DidFailToShareItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidShareItems => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSSharingServiceItemsEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSSharingServiceItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidShareItems += x, x => _data.DidShareItems -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillShareItems => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSSharingServiceItemsEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSSharingServiceItemsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillShareItems += x, x => _data.WillShareItems -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSSharingServicePickerEvents + { + private readonly global::AppKit.NSSharingServicePicker _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSSharingServicePickerEvents(global::AppKit.NSSharingServicePicker data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidChooseSharingService => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSSharingServicePickerDidChooseSharingServiceEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSSharingServicePickerDidChooseSharingServiceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidChooseSharingService += x, x => _data.DidChooseSharingService -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSSliderTouchBarItemEvents + { + private readonly global::AppKit.NSSliderTouchBarItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSSliderTouchBarItemEvents(global::AppKit.NSSliderTouchBarItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSSoundEvents + { + private readonly global::AppKit.NSSound _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSSoundEvents(global::AppKit.NSSound data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinishPlaying => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSSoundFinishedEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSSoundFinishedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinishPlaying += x, x => _data.DidFinishPlaying -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSStatusItemEvents + { + private readonly global::AppKit.NSStatusItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSStatusItemEvents(global::AppKit.NSStatusItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSTableViewEvents : global::AppKit.RxNSControlEvents + { + private readonly global::AppKit.NSTableView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSTableViewEvents(global::AppKit.NSTableView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDidMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDidMove += x, x => _data.ColumnDidMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ColumnDidResize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ColumnDidResize += x, x => _data.ColumnDidResize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddRowView => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSTableViewRowEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSTableViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddRowView += x, x => _data.DidAddRowView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidClickTableColumn => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSTableViewTableEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSTableViewTableEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidClickTableColumn += x, x => _data.DidClickTableColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDragTableColumn => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSTableViewTableEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSTableViewTableEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDragTableColumn += x, x => _data.DidDragTableColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveRowView => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSTableViewRowEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSTableViewRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveRowView += x, x => _data.DidRemoveRowView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DoubleClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DoubleClick += x, x => _data.DoubleClick -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MouseDownInHeaderOfTableColumn => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSTableViewTableEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSTableViewTableEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MouseDownInHeaderOfTableColumn += x, x => _data.MouseDownInHeaderOfTableColumn -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionDidChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionDidChange += x, x => _data.SelectionDidChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionIsChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionIsChanging += x, x => _data.SelectionIsChanging -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillDisplayCell => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSTableViewCellEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSTableViewCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillDisplayCell += x, x => _data.WillDisplayCell -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSTabViewEvents + { + private readonly global::AppKit.NSTabView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSTabViewEvents(global::AppKit.NSTabView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidSelect => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSTabViewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSTabViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidSelect += x, x => _data.DidSelect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NumberOfItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NumberOfItemsChanged += x, x => _data.NumberOfItemsChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillSelect => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSTabViewItemEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSTabViewItemEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillSelect += x, x => _data.WillSelect -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSTextEvents + { + private readonly global::AppKit.NSText _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSTextEvents(global::AppKit.NSText data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextDidBeginEditing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextDidBeginEditing += x, x => _data.TextDidBeginEditing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextDidChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextDidChange += x, x => _data.TextDidChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextDidEndEditing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextDidEndEditing += x, x => _data.TextDidEndEditing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSTextFieldEvents : global::AppKit.RxNSControlEvents + { + private readonly global::AppKit.NSTextField _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSTextFieldEvents(global::AppKit.NSTextField data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Changed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Changed += x, x => _data.Changed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFailToValidatePartialString => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSControlTextErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSControlTextErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFailToValidatePartialString += x, x => _data.DidFailToValidatePartialString -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingBegan => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingBegan += x, x => _data.EditingBegan -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EditingEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EditingEnded += x, x => _data.EditingEnded -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSTextStorageEvents + { + private readonly global::AppKit.NSTextStorage _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSTextStorageEvents(global::AppKit.NSTextStorage data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidProcessEditing => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSTextStorageEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSTextStorageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidProcessEditing += x, x => _data.DidProcessEditing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextStorageDidProcessEditing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextStorageDidProcessEditing += x, x => _data.TextStorageDidProcessEditing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TextStorageWillProcessEditing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TextStorageWillProcessEditing += x, x => _data.TextStorageWillProcessEditing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillProcessEditing => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSTextStorageEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSTextStorageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillProcessEditing += x, x => _data.WillProcessEditing -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSTextViewEvents : global::AppKit.RxNSTextEvents + { + private readonly global::AppKit.NSTextView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSTextViewEvents(global::AppKit.NSTextView data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellClicked => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSTextViewClickedEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSTextViewClickedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellClicked += x, x => _data.CellClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellDoubleClicked => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSTextViewDoubleClickEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSTextViewDoubleClickEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellDoubleClicked += x, x => _data.CellDoubleClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidChangeSelection => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidChangeSelection += x, x => _data.DidChangeSelection -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidChangeTypingAttributes => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidChangeTypingAttributes += x, x => _data.DidChangeTypingAttributes -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DraggedCell => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSTextViewDraggedCellEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSTextViewDraggedCellEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DraggedCell += x, x => _data.DraggedCell -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSToolbarEvents + { + private readonly global::AppKit.NSToolbar _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSToolbarEvents(global::AppKit.NSToolbar data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveItem += x, x => _data.DidRemoveItem -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillAddItem => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillAddItem += x, x => _data.WillAddItem -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSToolbarItemEvents + { + private readonly global::AppKit.NSToolbarItem _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSToolbarItemEvents(global::AppKit.NSToolbarItem data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Activated += x, x => _data.Activated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSWindowEvents + { + private readonly global::AppKit.NSWindow _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSWindowEvents(global::AppKit.NSWindow data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidBecomeKey => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidBecomeKey += x, x => _data.DidBecomeKey -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidBecomeMain => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidBecomeMain += x, x => _data.DidBecomeMain -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidChangeBackingProperties => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidChangeBackingProperties += x, x => _data.DidChangeBackingProperties -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidChangeScreen => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidChangeScreen += x, x => _data.DidChangeScreen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidChangeScreenProfile => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidChangeScreenProfile += x, x => _data.DidChangeScreenProfile -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDecodeRestorableState => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSWindowCoderEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSWindowCoderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDecodeRestorableState += x, x => _data.DidDecodeRestorableState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDeminiaturize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDeminiaturize += x, x => _data.DidDeminiaturize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEndLiveResize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEndLiveResize += x, x => _data.DidEndLiveResize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEndSheet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEndSheet += x, x => _data.DidEndSheet -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEnterFullScreen => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEnterFullScreen += x, x => _data.DidEnterFullScreen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEnterVersionBrowser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEnterVersionBrowser += x, x => _data.DidEnterVersionBrowser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidExitFullScreen => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidExitFullScreen += x, x => _data.DidExitFullScreen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidExitVersionBrowser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidExitVersionBrowser += x, x => _data.DidExitVersionBrowser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidExpose => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidExpose += x, x => _data.DidExpose -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFailToEnterFullScreen => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFailToEnterFullScreen += x, x => _data.DidFailToEnterFullScreen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFailToExitFullScreen => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFailToExitFullScreen += x, x => _data.DidFailToExitFullScreen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidMiniaturize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidMiniaturize += x, x => _data.DidMiniaturize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidMove += x, x => _data.DidMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidResignKey => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidResignKey += x, x => _data.DidResignKey -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidResignMain => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidResignMain += x, x => _data.DidResignMain -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidResize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidResize += x, x => _data.DidResize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdate += x, x => _data.DidUpdate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartCustomAnimationToEnterFullScreen => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSWindowDurationEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSWindowDurationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartCustomAnimationToEnterFullScreen += x, x => _data.StartCustomAnimationToEnterFullScreen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartCustomAnimationToExitFullScreen => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSWindowDurationEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSWindowDurationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartCustomAnimationToExitFullScreen += x, x => _data.StartCustomAnimationToExitFullScreen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillBeginSheet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillBeginSheet += x, x => _data.WillBeginSheet -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillClose => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillClose += x, x => _data.WillClose -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillEncodeRestorableState => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSWindowCoderEventArgs>(eventHandler => + { + void Handler(object sender, global::AppKit.NSWindowCoderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillEncodeRestorableState += x, x => _data.WillEncodeRestorableState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillEnterFullScreen => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillEnterFullScreen += x, x => _data.WillEnterFullScreen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillEnterVersionBrowser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillEnterVersionBrowser += x, x => _data.WillEnterVersionBrowser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillExitFullScreen => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillExitFullScreen += x, x => _data.WillExitFullScreen -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillExitVersionBrowser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillExitVersionBrowser += x, x => _data.WillExitVersionBrowser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillMiniaturize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillMiniaturize += x, x => _data.WillMiniaturize -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillMove => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillMove += x, x => _data.WillMove -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillStartLiveResize => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillStartLiveResize += x, x => _data.WillStartLiveResize -= x); + } +} + +namespace AudioToolbox +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxInputAudioQueueEvents Events(this global::AudioToolbox.InputAudioQueue item) => new RxInputAudioQueueEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxOutputAudioQueueEvents Events(this global::AudioToolbox.OutputAudioQueue item) => new RxOutputAudioQueueEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxInputAudioQueueEvents + { + private readonly global::AudioToolbox.InputAudioQueue _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxInputAudioQueueEvents(global::AudioToolbox.InputAudioQueue data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InputCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::AudioToolbox.InputCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::AudioToolbox.InputCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InputCompleted += x, x => _data.InputCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxOutputAudioQueueEvents + { + private readonly global::AudioToolbox.OutputAudioQueue _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxOutputAudioQueueEvents(global::AudioToolbox.OutputAudioQueue data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::AudioToolbox.BufferCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::AudioToolbox.BufferCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferCompleted += x, x => _data.BufferCompleted -= x); + } +} + +namespace AVFoundation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAVAudioPlayerEvents Events(this global::AVFoundation.AVAudioPlayer item) => new RxAVAudioPlayerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAVAudioRecorderEvents Events(this global::AVFoundation.AVAudioRecorder item) => new RxAVAudioRecorderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAVSpeechSynthesizerEvents Events(this global::AVFoundation.AVSpeechSynthesizer item) => new RxAVSpeechSynthesizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAVAudioPlayerEvents + { + private readonly global::AVFoundation.AVAudioPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAVAudioPlayerEvents(global::AVFoundation.AVAudioPlayer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginInterruption => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginInterruption += x, x => _data.BeginInterruption -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecoderError => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecoderError += x, x => _data.DecoderError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndInterruption => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndInterruption += x, x => _data.EndInterruption -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FinishedPlaying => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVStatusEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVStatusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FinishedPlaying += x, x => _data.FinishedPlaying -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAVAudioRecorderEvents + { + private readonly global::AVFoundation.AVAudioRecorder _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAVAudioRecorderEvents(global::AVFoundation.AVAudioRecorder data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BeginInterruption => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BeginInterruption += x, x => _data.BeginInterruption -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncoderError => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncoderError += x, x => _data.EncoderError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EndInterruption => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EndInterruption += x, x => _data.EndInterruption -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FinishedRecording => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVStatusEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVStatusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FinishedRecording += x, x => _data.FinishedRecording -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAVSpeechSynthesizerEvents + { + private readonly global::AVFoundation.AVSpeechSynthesizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAVSpeechSynthesizerEvents(global::AVFoundation.AVSpeechSynthesizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidCancelSpeechUtterance => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidCancelSpeechUtterance += x, x => _data.DidCancelSpeechUtterance -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidContinueSpeechUtterance => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidContinueSpeechUtterance += x, x => _data.DidContinueSpeechUtterance -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinishSpeechUtterance => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinishSpeechUtterance += x, x => _data.DidFinishSpeechUtterance -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidPauseSpeechUtterance => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidPauseSpeechUtterance += x, x => _data.DidPauseSpeechUtterance -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidStartSpeechUtterance => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidStartSpeechUtterance += x, x => _data.DidStartSpeechUtterance -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillSpeakRangeOfSpeechString => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerWillSpeakEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerWillSpeakEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillSpeakRangeOfSpeechString += x, x => _data.WillSpeakRangeOfSpeechString -= x); + } +} + +namespace CoreAnimation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCAAnimationEvents Events(this global::CoreAnimation.CAAnimation item) => new RxCAAnimationEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCAAnimationEvents + { + private readonly global::CoreAnimation.CAAnimation _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCAAnimationEvents(global::CoreAnimation.CAAnimation data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnimationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnimationStarted += x, x => _data.AnimationStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AnimationStopped => global::System.Reactive.Linq.Observable.FromEvent, global::CoreAnimation.CAAnimationStateEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreAnimation.CAAnimationStateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AnimationStopped += x, x => _data.AnimationStopped -= x); + } +} + +namespace CoreBluetooth +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCBCentralManagerEvents Events(this global::CoreBluetooth.CBCentralManager item) => new RxCBCentralManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCBPeripheralEvents Events(this global::CoreBluetooth.CBPeripheral item) => new RxCBPeripheralEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCBPeripheralManagerEvents Events(this global::CoreBluetooth.CBPeripheralManager item) => new RxCBPeripheralManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCBCentralManagerEvents + { + private readonly global::CoreBluetooth.CBCentralManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCBCentralManagerEvents(global::CoreBluetooth.CBCentralManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ConnectedPeripheral => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ConnectedPeripheral += x, x => _data.ConnectedPeripheral -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisconnectedPeripheral => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisconnectedPeripheral += x, x => _data.DisconnectedPeripheral -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DiscoveredPeripheral => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBDiscoveredPeripheralEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBDiscoveredPeripheralEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DiscoveredPeripheral += x, x => _data.DiscoveredPeripheral -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FailedToConnectPeripheral => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FailedToConnectPeripheral += x, x => _data.FailedToConnectPeripheral -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrievedConnectedPeripherals => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralsEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrievedConnectedPeripherals += x, x => _data.RetrievedConnectedPeripherals -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RetrievedPeripherals => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralsEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RetrievedPeripherals += x, x => _data.RetrievedPeripherals -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedState => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedState += x, x => _data.UpdatedState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillRestoreState => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBWillRestoreEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBWillRestoreEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillRestoreState += x, x => _data.WillRestoreState -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCBPeripheralEvents + { + private readonly global::CoreBluetooth.CBPeripheral _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCBPeripheralEvents(global::CoreBluetooth.CBPeripheral data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidOpenL2CapChannel => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralOpenL2CapChannelEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralOpenL2CapChannelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidOpenL2CapChannel += x, x => _data.DidOpenL2CapChannel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DiscoveredCharacteristic => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBServiceEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBServiceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DiscoveredCharacteristic += x, x => _data.DiscoveredCharacteristic -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DiscoveredDescriptor => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBCharacteristicEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBCharacteristicEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DiscoveredDescriptor += x, x => _data.DiscoveredDescriptor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DiscoveredIncludedService => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBServiceEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBServiceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DiscoveredIncludedService += x, x => _data.DiscoveredIncludedService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DiscoveredService => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DiscoveredService += x, x => _data.DiscoveredService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable InvalidatedService => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.InvalidatedService += x, x => _data.InvalidatedService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsReadyToSendWriteWithoutResponse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsReadyToSendWriteWithoutResponse += x, x => _data.IsReadyToSendWriteWithoutResponse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedServices => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralServicesEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralServicesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedServices += x, x => _data.ModifiedServices -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RssiRead => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBRssiEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBRssiEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RssiRead += x, x => _data.RssiRead -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RssiUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RssiUpdated += x, x => _data.RssiUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedCharacterteristicValue => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBCharacteristicEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBCharacteristicEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedCharacterteristicValue += x, x => _data.UpdatedCharacterteristicValue -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedName => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedName += x, x => _data.UpdatedName -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedNotificationState => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBCharacteristicEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBCharacteristicEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedNotificationState += x, x => _data.UpdatedNotificationState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedValue => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBDescriptorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBDescriptorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedValue += x, x => _data.UpdatedValue -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WroteCharacteristicValue => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBCharacteristicEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBCharacteristicEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WroteCharacteristicValue += x, x => _data.WroteCharacteristicValue -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WroteDescriptorValue => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBDescriptorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBDescriptorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WroteDescriptorValue += x, x => _data.WroteDescriptorValue -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCBPeripheralManagerEvents + { + private readonly global::CoreBluetooth.CBPeripheralManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCBPeripheralManagerEvents(global::CoreBluetooth.CBPeripheralManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AdvertisingStarted => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AdvertisingStarted += x, x => _data.AdvertisingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CharacteristicSubscribed => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerSubscriptionEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerSubscriptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CharacteristicSubscribed += x, x => _data.CharacteristicSubscribed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CharacteristicUnsubscribed => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerSubscriptionEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerSubscriptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CharacteristicUnsubscribed += x, x => _data.CharacteristicUnsubscribed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidOpenL2CapChannel => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerOpenL2CapChannelEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerOpenL2CapChannelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidOpenL2CapChannel += x, x => _data.DidOpenL2CapChannel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidPublishL2CapChannel => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerL2CapChannelOperationEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerL2CapChannelOperationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidPublishL2CapChannel += x, x => _data.DidPublishL2CapChannel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUnpublishL2CapChannel => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerL2CapChannelOperationEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerL2CapChannelOperationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUnpublishL2CapChannel += x, x => _data.DidUnpublishL2CapChannel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadRequestReceived => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBATTRequestEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBATTRequestEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadRequestReceived += x, x => _data.ReadRequestReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadyToUpdateSubscribers => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadyToUpdateSubscribers += x, x => _data.ReadyToUpdateSubscribers -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ServiceAdded => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerServiceEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerServiceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ServiceAdded += x, x => _data.ServiceAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateUpdated += x, x => _data.StateUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillRestoreState => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBWillRestoreEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBWillRestoreEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillRestoreState += x, x => _data.WillRestoreState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WriteRequestsReceived => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBATTRequestsEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBATTRequestsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WriteRequestsReceived += x, x => _data.WriteRequestsReceived -= x); + } +} + +namespace CoreFoundation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCFSocketEvents Events(this global::CoreFoundation.CFSocket item) => new RxCFSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCFStreamEvents Events(this global::CoreFoundation.CFStream item) => new RxCFStreamEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCFSocketEvents + { + private readonly global::CoreFoundation.CFSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCFSocketEvents(global::CoreFoundation.CFSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFSocket.CFSocketAcceptEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFSocket.CFSocketAcceptEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptEvent += x, x => _data.AcceptEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ConnectEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFSocket.CFSocketConnectEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFSocket.CFSocketConnectEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ConnectEvent += x, x => _data.ConnectEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFSocket.CFSocketDataEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFSocket.CFSocketDataEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataEvent += x, x => _data.DataEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFSocket.CFSocketReadEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFSocket.CFSocketReadEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadEvent += x, x => _data.ReadEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WriteEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFSocket.CFSocketWriteEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFSocket.CFSocketWriteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WriteEvent += x, x => _data.WriteEvent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCFStreamEvents + { + private readonly global::CoreFoundation.CFStream _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCFStreamEvents(global::CoreFoundation.CFStream data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanAcceptBytesEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFStream.StreamEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFStream.StreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanAcceptBytesEvent += x, x => _data.CanAcceptBytesEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClosedEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFStream.StreamEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFStream.StreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClosedEvent += x, x => _data.ClosedEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFStream.StreamEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFStream.StreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorEvent += x, x => _data.ErrorEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HasBytesAvailableEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFStream.StreamEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFStream.StreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HasBytesAvailableEvent += x, x => _data.HasBytesAvailableEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OpenCompletedEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFStream.StreamEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFStream.StreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OpenCompletedEvent += x, x => _data.OpenCompletedEvent -= x); + } +} + +namespace CoreLocation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCLLocationManagerEvents Events(this global::CoreLocation.CLLocationManager item) => new RxCLLocationManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCLLocationManagerEvents + { + private readonly global::CoreLocation.CLLocationManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCLLocationManagerEvents(global::CoreLocation.CLLocationManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorizationChanged => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLAuthorizationChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLAuthorizationChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorizationChanged += x, x => _data.AuthorizationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DeferredUpdatesFinished => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DeferredUpdatesFinished += x, x => _data.DeferredUpdatesFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidChangeAuthorization => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidChangeAuthorization += x, x => _data.DidChangeAuthorization -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDetermineState => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionStateDeterminedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionStateDeterminedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDetermineState += x, x => _data.DidDetermineState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFailRangingBeacons => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionBeaconsConstraintFailedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionBeaconsConstraintFailedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFailRangingBeacons += x, x => _data.DidFailRangingBeacons -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRangeBeaconsSatisfyingConstraint => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionBeaconsConstraintRangedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionBeaconsConstraintRangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRangeBeaconsSatisfyingConstraint += x, x => _data.DidRangeBeaconsSatisfyingConstraint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidStartMonitoringForRegion => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidStartMonitoringForRegion += x, x => _data.DidStartMonitoringForRegion -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidVisit => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLVisitedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLVisitedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidVisit += x, x => _data.DidVisit -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Failed => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationsUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLLocationsUpdatedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLLocationsUpdatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationsUpdated += x, x => _data.LocationsUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationUpdatesPaused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationUpdatesPaused += x, x => _data.LocationUpdatesPaused -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationUpdatesResumed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationUpdatesResumed += x, x => _data.LocationUpdatesResumed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MonitoringFailed => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MonitoringFailed += x, x => _data.MonitoringFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionEntered => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionEntered += x, x => _data.RegionEntered -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionLeft => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLRegionEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLRegionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionLeft += x, x => _data.RegionLeft -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedHeading => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLHeadingUpdatedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLHeadingUpdatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedHeading += x, x => _data.UpdatedHeading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedLocation => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLLocationUpdatedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLLocationUpdatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedLocation += x, x => _data.UpdatedLocation -= x); + } +} + +namespace CoreMidi +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMidiClientEvents Events(this global::CoreMidi.MidiClient item) => new RxMidiClientEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMidiEndpointEvents Events(this global::CoreMidi.MidiEndpoint item) => new RxMidiEndpointEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMidiPortEvents Events(this global::CoreMidi.MidiPort item) => new RxMidiPortEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMidiClientEvents + { + private readonly global::CoreMidi.MidiClient _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMidiClientEvents(global::CoreMidi.MidiClient data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IOError => global::System.Reactive.Linq.Observable.FromEvent, global::CoreMidi.IOErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreMidi.IOErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IOError += x, x => _data.IOError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ObjectAdded => global::System.Reactive.Linq.Observable.FromEvent, global::CoreMidi.ObjectAddedOrRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreMidi.ObjectAddedOrRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ObjectAdded += x, x => _data.ObjectAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ObjectRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::CoreMidi.ObjectAddedOrRemovedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreMidi.ObjectAddedOrRemovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ObjectRemoved += x, x => _data.ObjectRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::CoreMidi.ObjectPropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreMidi.ObjectPropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SerialPortOwnerChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SerialPortOwnerChanged += x, x => _data.SerialPortOwnerChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SetupChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SetupChanged += x, x => _data.SetupChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ThruConnectionsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ThruConnectionsChanged += x, x => _data.ThruConnectionsChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMidiEndpointEvents + { + private readonly global::CoreMidi.MidiEndpoint _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMidiEndpointEvents(global::CoreMidi.MidiEndpoint data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, global::CoreMidi.MidiPacketsEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreMidi.MidiPacketsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMidiPortEvents + { + private readonly global::CoreMidi.MidiPort _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMidiPortEvents(global::CoreMidi.MidiPort data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, global::CoreMidi.MidiPacketsEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreMidi.MidiPacketsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + } +} + +namespace CoreServices +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxFSEventStreamEvents Events(this global::CoreServices.FSEventStream item) => new RxFSEventStreamEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxFSEventStreamEvents + { + private readonly global::CoreServices.FSEventStream _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxFSEventStreamEvents(global::CoreServices.FSEventStream data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Events => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::CoreServices.FSEventStreamEventsArgs args) => eventHandler(args); + return Handler; + }, x => _data.Events += x, x => _data.Events -= x); + } +} + +namespace ExternalAccessory +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxEAAccessoryEvents Events(this global::ExternalAccessory.EAAccessory item) => new RxEAAccessoryEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxEAAccessoryEvents + { + private readonly global::ExternalAccessory.EAAccessory _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxEAAccessoryEvents(global::ExternalAccessory.EAAccessory data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Disconnected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Disconnected += x, x => _data.Disconnected -= x); + } +} + +namespace Foundation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSCacheEvents Events(this global::Foundation.NSCache item) => new RxNSCacheEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSKeyedArchiverEvents Events(this global::Foundation.NSKeyedArchiver item) => new RxNSKeyedArchiverEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSKeyedUnarchiverEvents Events(this global::Foundation.NSKeyedUnarchiver item) => new RxNSKeyedUnarchiverEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSNetServiceEvents Events(this global::Foundation.NSNetService item) => new RxNSNetServiceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSNetServiceBrowserEvents Events(this global::Foundation.NSNetServiceBrowser item) => new RxNSNetServiceBrowserEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSStreamEvents Events(this global::Foundation.NSStream item) => new RxNSStreamEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSUserNotificationCenterEvents Events(this global::Foundation.NSUserNotificationCenter item) => new RxNSUserNotificationCenterEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSCacheEvents + { + private readonly global::Foundation.NSCache _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSCacheEvents(global::Foundation.NSCache data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillEvictObject => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSObjectEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSObjectEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillEvictObject += x, x => _data.WillEvictObject -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSKeyedArchiverEvents + { + private readonly global::Foundation.NSKeyedArchiver _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSKeyedArchiverEvents(global::Foundation.NSKeyedArchiver data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncodedObject => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSObjectEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSObjectEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncodedObject += x, x => _data.EncodedObject -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finished += x, x => _data.Finished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finishing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finishing += x, x => _data.Finishing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReplacingObject => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSArchiveReplaceEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSArchiveReplaceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReplacingObject += x, x => _data.ReplacingObject -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSKeyedUnarchiverEvents + { + private readonly global::Foundation.NSKeyedUnarchiver _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSKeyedUnarchiverEvents(global::Foundation.NSKeyedUnarchiver data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finished += x, x => _data.Finished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finishing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finishing += x, x => _data.Finishing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReplacingObject => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSArchiveReplaceEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSArchiveReplaceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReplacingObject += x, x => _data.ReplacingObject -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSNetServiceEvents + { + private readonly global::Foundation.NSNetService _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSNetServiceEvents(global::Foundation.NSNetService data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AddressResolved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AddressResolved += x, x => _data.AddressResolved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAcceptConnection => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetServiceConnectionEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetServiceConnectionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAcceptConnection += x, x => _data.DidAcceptConnection -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Published => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Published += x, x => _data.Published -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PublishFailure => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetServiceErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetServiceErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PublishFailure += x, x => _data.PublishFailure -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResolveFailure => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetServiceErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetServiceErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResolveFailure += x, x => _data.ResolveFailure -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Stopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Stopped += x, x => _data.Stopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedTxtRecordData => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetServiceDataEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetServiceDataEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedTxtRecordData += x, x => _data.UpdatedTxtRecordData -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillPublish => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillPublish += x, x => _data.WillPublish -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillResolve => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillResolve += x, x => _data.WillResolve -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSNetServiceBrowserEvents + { + private readonly global::Foundation.NSNetServiceBrowser _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSNetServiceBrowserEvents(global::Foundation.NSNetServiceBrowser data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DomainRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetDomainEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetDomainEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DomainRemoved += x, x => _data.DomainRemoved -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FoundDomain => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetDomainEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetDomainEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FoundDomain += x, x => _data.FoundDomain -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FoundService => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetServiceEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetServiceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FoundService += x, x => _data.FoundService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable NotSearched => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetServiceErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetServiceErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.NotSearched += x, x => _data.NotSearched -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchStarted += x, x => _data.SearchStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchStopped += x, x => _data.SearchStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ServiceRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSNetServiceEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSNetServiceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ServiceRemoved += x, x => _data.ServiceRemoved -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSStreamEvents + { + private readonly global::Foundation.NSStream _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSStreamEvents(global::Foundation.NSStream data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OnEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSStreamEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSStreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OnEvent += x, x => _data.OnEvent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSUserNotificationCenterEvents + { + private readonly global::Foundation.NSUserNotificationCenter _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSUserNotificationCenterEvents(global::Foundation.NSUserNotificationCenter data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidActivateNotification => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.UNCDidActivateNotificationEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.UNCDidActivateNotificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidActivateNotification += x, x => _data.DidActivateNotification -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDeliverNotification => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.UNCDidDeliverNotificationEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.UNCDidDeliverNotificationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDeliverNotification += x, x => _data.DidDeliverNotification -= x); + } +} + +namespace GameKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGKAchievementViewControllerEvents Events(this global::GameKit.GKAchievementViewController item) => new RxGKAchievementViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGKChallengeEventHandlerEvents Events(this global::GameKit.GKChallengeEventHandler item) => new RxGKChallengeEventHandlerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGKFriendRequestComposeViewControllerEvents Events(this global::GameKit.GKFriendRequestComposeViewController item) => new RxGKFriendRequestComposeViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGKGameCenterViewControllerEvents Events(this global::GameKit.GKGameCenterViewController item) => new RxGKGameCenterViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGKLeaderboardViewControllerEvents Events(this global::GameKit.GKLeaderboardViewController item) => new RxGKLeaderboardViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGKMatchEvents Events(this global::GameKit.GKMatch item) => new RxGKMatchEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGKMatchmakerViewControllerEvents Events(this global::GameKit.GKMatchmakerViewController item) => new RxGKMatchmakerViewControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGKAchievementViewControllerEvents : global::GameKit.RxGKGameCenterViewControllerEvents + { + private readonly global::GameKit.GKAchievementViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGKAchievementViewControllerEvents(global::GameKit.GKAchievementViewController data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinish => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinish += x, x => _data.DidFinish -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGKChallengeEventHandlerEvents + { + private readonly global::GameKit.GKChallengeEventHandler _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGKChallengeEventHandlerEvents(global::GameKit.GKChallengeEventHandler data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocalPlayerCompletedChallenge => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocalPlayerCompletedChallenge += x, x => _data.LocalPlayerCompletedChallenge -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocalPlayerReceivedChallenge => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocalPlayerReceivedChallenge += x, x => _data.LocalPlayerReceivedChallenge -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocalPlayerSelectedChallenge => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocalPlayerSelectedChallenge += x, x => _data.LocalPlayerSelectedChallenge -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RemotePlayerCompletedChallenge => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RemotePlayerCompletedChallenge += x, x => _data.RemotePlayerCompletedChallenge -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGKFriendRequestComposeViewControllerEvents + { + private readonly global::GameKit.GKFriendRequestComposeViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGKFriendRequestComposeViewControllerEvents(global::GameKit.GKFriendRequestComposeViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinish => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinish += x, x => _data.DidFinish -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGKGameCenterViewControllerEvents + { + private readonly global::GameKit.GKGameCenterViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGKGameCenterViewControllerEvents(global::GameKit.GKGameCenterViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finished += x, x => _data.Finished -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGKLeaderboardViewControllerEvents : global::GameKit.RxGKGameCenterViewControllerEvents + { + private readonly global::GameKit.GKLeaderboardViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGKLeaderboardViewControllerEvents(global::GameKit.GKLeaderboardViewController data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinish => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinish += x, x => _data.DidFinish -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGKMatchEvents + { + private readonly global::GameKit.GKMatch _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGKMatchEvents(global::GameKit.GKMatch data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + [global::System.ObsoleteAttribute("It will never be called.", false)] + public global::System.IObservable ConnectionFailed => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKPlayerErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKPlayerErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ConnectionFailed += x, x => _data.ConnectionFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataReceived => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKDataEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKDataEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataReceivedForRecipient => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKDataReceivedForRecipientEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKDataReceivedForRecipientEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataReceivedForRecipient += x, x => _data.DataReceivedForRecipient -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataReceivedFromPlayer => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKMatchReceivedDataFromRemotePlayerEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKMatchReceivedDataFromRemotePlayerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataReceivedFromPlayer += x, x => _data.DataReceivedFromPlayer -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Failed => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKStateEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKStateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateChangedForPlayer => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKMatchConnectionChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKMatchConnectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateChangedForPlayer += x, x => _data.StateChangedForPlayer -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGKMatchmakerViewControllerEvents + { + private readonly global::GameKit.GKMatchmakerViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGKMatchmakerViewControllerEvents(global::GameKit.GKMatchmakerViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFailWithError => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFailWithError += x, x => _data.DidFailWithError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFindHostedPlayers => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKMatchmakingPlayersEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKMatchmakingPlayersEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFindHostedPlayers += x, x => _data.DidFindHostedPlayers -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFindMatch => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKMatchEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKMatchEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFindMatch += x, x => _data.DidFindMatch -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFindPlayers => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKPlayersEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKPlayersEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFindPlayers += x, x => _data.DidFindPlayers -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HostedPlayerDidAccept => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKMatchmakingPlayerEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKMatchmakingPlayerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HostedPlayerDidAccept += x, x => _data.HostedPlayerDidAccept -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReceivedAcceptFromHostedPlayer => global::System.Reactive.Linq.Observable.FromEvent, global::GameKit.GKPlayerEventArgs>(eventHandler => + { + void Handler(object sender, global::GameKit.GKPlayerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReceivedAcceptFromHostedPlayer += x, x => _data.ReceivedAcceptFromHostedPlayer -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WasCancelled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WasCancelled += x, x => _data.WasCancelled -= x); + } +} + +namespace ImageKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIKCameraDeviceViewEvents Events(this global::ImageKit.IKCameraDeviceView item) => new RxIKCameraDeviceViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIKDeviceBrowserViewEvents Events(this global::ImageKit.IKDeviceBrowserView item) => new RxIKDeviceBrowserViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIKImageBrowserViewEvents Events(this global::ImageKit.IKImageBrowserView item) => new RxIKImageBrowserViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIKScannerDeviceViewEvents Events(this global::ImageKit.IKScannerDeviceView item) => new RxIKScannerDeviceViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIKCameraDeviceViewEvents + { + private readonly global::ImageKit.IKCameraDeviceView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIKCameraDeviceViewEvents(global::ImageKit.IKCameraDeviceView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDownloadFile => global::System.Reactive.Linq.Observable.FromEvent, global::ImageKit.IKCameraDeviceViewICCameraFileNSUrlNSDataNSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::ImageKit.IKCameraDeviceViewICCameraFileNSUrlNSDataNSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDownloadFile += x, x => _data.DidDownloadFile -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEncounterError => global::System.Reactive.Linq.Observable.FromEvent, global::ImageKit.IKCameraDeviceViewNSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::ImageKit.IKCameraDeviceViewNSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEncounterError += x, x => _data.DidEncounterError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionDidChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionDidChange += x, x => _data.SelectionDidChange -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIKDeviceBrowserViewEvents + { + private readonly global::ImageKit.IKDeviceBrowserView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIKDeviceBrowserViewEvents(global::ImageKit.IKDeviceBrowserView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEncounterError => global::System.Reactive.Linq.Observable.FromEvent, global::ImageKit.IKDeviceBrowserViewNSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::ImageKit.IKDeviceBrowserViewNSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEncounterError += x, x => _data.DidEncounterError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionDidChange => global::System.Reactive.Linq.Observable.FromEvent, global::ImageKit.IKDeviceBrowserViewICDeviceEventArgs>(eventHandler => + { + void Handler(object sender, global::ImageKit.IKDeviceBrowserViewICDeviceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionDidChange += x, x => _data.SelectionDidChange -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIKImageBrowserViewEvents + { + private readonly global::ImageKit.IKImageBrowserView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIKImageBrowserViewEvents(global::ImageKit.IKImageBrowserView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BackgroundWasRightClicked => global::System.Reactive.Linq.Observable.FromEvent, global::ImageKit.IKImageBrowserViewEventEventArgs>(eventHandler => + { + void Handler(object sender, global::ImageKit.IKImageBrowserViewEventEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BackgroundWasRightClicked += x, x => _data.BackgroundWasRightClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellWasDoubleClicked => global::System.Reactive.Linq.Observable.FromEvent, global::ImageKit.IKImageBrowserViewIndexEventArgs>(eventHandler => + { + void Handler(object sender, global::ImageKit.IKImageBrowserViewIndexEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellWasDoubleClicked += x, x => _data.CellWasDoubleClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CellWasRightClicked => global::System.Reactive.Linq.Observable.FromEvent, global::ImageKit.IKImageBrowserViewIndexEventEventArgs>(eventHandler => + { + void Handler(object sender, global::ImageKit.IKImageBrowserViewIndexEventEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CellWasRightClicked += x, x => _data.CellWasRightClicked -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SelectionDidChange => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SelectionDidChange += x, x => _data.SelectionDidChange -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIKScannerDeviceViewEvents + { + private readonly global::ImageKit.IKScannerDeviceView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIKScannerDeviceViewEvents(global::ImageKit.IKScannerDeviceView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEncounterError => global::System.Reactive.Linq.Observable.FromEvent, global::ImageKit.IKScannerDeviceViewErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::ImageKit.IKScannerDeviceViewErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEncounterError += x, x => _data.DidEncounterError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidScan => global::System.Reactive.Linq.Observable.FromEvent, global::ImageKit.IKScannerDeviceViewScanEventArgs>(eventHandler => + { + void Handler(object sender, global::ImageKit.IKScannerDeviceViewScanEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidScan += x, x => _data.DidScan -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidScanToBandData => global::System.Reactive.Linq.Observable.FromEvent, global::ImageKit.IKScannerDeviceViewScanBandDataEventArgs>(eventHandler => + { + void Handler(object sender, global::ImageKit.IKScannerDeviceViewScanBandDataEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidScanToBandData += x, x => _data.DidScanToBandData -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidScanToUrl => global::System.Reactive.Linq.Observable.FromEvent, global::ImageKit.IKScannerDeviceViewScanUrlEventArgs>(eventHandler => + { + void Handler(object sender, global::ImageKit.IKScannerDeviceViewScanUrlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidScanToUrl += x, x => _data.DidScanToUrl -= x); + } +} + +namespace MapKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMKMapViewEvents Events(this global::MapKit.MKMapView item) => new RxMKMapViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMKMapViewEvents + { + private readonly global::MapKit.MKMapView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMKMapViewEvents(global::MapKit.MKMapView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangedDragState => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKMapViewDragStateEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKMapViewDragStateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangedDragState += x, x => _data.ChangedDragState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddAnnotationViews => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKMapViewAnnotationEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKMapViewAnnotationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddAnnotationViews += x, x => _data.DidAddAnnotationViews -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddOverlayRenderers => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKDidAddOverlayRenderersEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKDidAddOverlayRenderersEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddOverlayRenderers += x, x => _data.DidAddOverlayRenderers -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidChangeUserTrackingMode => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MMapViewUserTrackingEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MMapViewUserTrackingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidChangeUserTrackingMode += x, x => _data.DidChangeUserTrackingMode -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidChangeVisibleRegion => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidChangeVisibleRegion += x, x => _data.DidChangeVisibleRegion -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDeselectAnnotationView => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKAnnotationViewEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKAnnotationViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDeselectAnnotationView += x, x => _data.DidDeselectAnnotationView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFailToLocateUser => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFailToLocateUser += x, x => _data.DidFailToLocateUser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinishRenderingMap => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKDidFinishRenderingMapEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKDidFinishRenderingMapEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinishRenderingMap += x, x => _data.DidFinishRenderingMap -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidSelectAnnotationView => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKAnnotationViewEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKAnnotationViewEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidSelectAnnotationView += x, x => _data.DidSelectAnnotationView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidStopLocatingUser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidStopLocatingUser += x, x => _data.DidStopLocatingUser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateUserLocation => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKUserLocationEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKUserLocationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateUserLocation += x, x => _data.DidUpdateUserLocation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LoadingMapFailed => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LoadingMapFailed += x, x => _data.LoadingMapFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MapLoaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MapLoaded += x, x => _data.MapLoaded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKMapViewChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKMapViewChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionChanged += x, x => _data.RegionChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RegionWillChange => global::System.Reactive.Linq.Observable.FromEvent, global::MapKit.MKMapViewChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::MapKit.MKMapViewChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RegionWillChange += x, x => _data.RegionWillChange -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillStartLoadingMap => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillStartLoadingMap += x, x => _data.WillStartLoadingMap -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillStartLocatingUser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillStartLocatingUser += x, x => _data.WillStartLocatingUser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillStartRenderingMap => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillStartRenderingMap += x, x => _data.WillStartRenderingMap -= x); + } +} + +namespace NotificationCenter +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNCWidgetListViewControllerEvents Events(this global::NotificationCenter.NCWidgetListViewController item) => new RxNCWidgetListViewControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNCWidgetSearchViewControllerEvents Events(this global::NotificationCenter.NCWidgetSearchViewController item) => new RxNCWidgetSearchViewControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNCWidgetListViewControllerEvents + { + private readonly global::NotificationCenter.NCWidgetListViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNCWidgetListViewControllerEvents(global::NotificationCenter.NCWidgetListViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveRow => global::System.Reactive.Linq.Observable.FromEvent, global::NotificationCenter.NCWidgetListViewControllerDidRemoveRowEventArgs>(eventHandler => + { + void Handler(object sender, global::NotificationCenter.NCWidgetListViewControllerDidRemoveRowEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveRow += x, x => _data.DidRemoveRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidReorderRow => global::System.Reactive.Linq.Observable.FromEvent, global::NotificationCenter.NCWidgetListViewControllerDidReorderEventArgs>(eventHandler => + { + void Handler(object sender, global::NotificationCenter.NCWidgetListViewControllerDidReorderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidReorderRow += x, x => _data.DidReorderRow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PerformAddAction => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PerformAddAction += x, x => _data.PerformAddAction -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNCWidgetSearchViewControllerEvents + { + private readonly global::NotificationCenter.NCWidgetSearchViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNCWidgetSearchViewControllerEvents(global::NotificationCenter.NCWidgetSearchViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ResultSelected => global::System.Reactive.Linq.Observable.FromEvent, global::NotificationCenter.NSWidgetSearchResultSelectedEventArgs>(eventHandler => + { + void Handler(object sender, global::NotificationCenter.NSWidgetSearchResultSelectedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ResultSelected += x, x => _data.ResultSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SearchForTearm => global::System.Reactive.Linq.Observable.FromEvent, global::NotificationCenter.NSWidgetSearchForTermEventArgs>(eventHandler => + { + void Handler(object sender, global::NotificationCenter.NSWidgetSearchForTermEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SearchForTearm += x, x => _data.SearchForTearm -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable TermCleared => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.TermCleared += x, x => _data.TermCleared -= x); + } +} + +namespace PassKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPKPaymentAuthorizationViewControllerEvents Events(this global::PassKit.PKPaymentAuthorizationViewController item) => new RxPKPaymentAuthorizationViewControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPKPaymentAuthorizationViewControllerEvents + { + private readonly global::PassKit.PKPaymentAuthorizationViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPKPaymentAuthorizationViewControllerEvents(global::PassKit.PKPaymentAuthorizationViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAuthorizePayment2 => global::System.Reactive.Linq.Observable.FromEvent, global::PassKit.PKPaymentAuthorizationResultEventArgs>(eventHandler => + { + void Handler(object sender, global::PassKit.PKPaymentAuthorizationResultEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAuthorizePayment2 += x, x => _data.DidAuthorizePayment2 -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRequestMerchantSessionUpdate => global::System.Reactive.Linq.Observable.FromEvent, global::PassKit.PKPaymentRequestMerchantSessionUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::PassKit.PKPaymentRequestMerchantSessionUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRequestMerchantSessionUpdate += x, x => _data.DidRequestMerchantSessionUpdate -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidSelectPaymentMethod2 => global::System.Reactive.Linq.Observable.FromEvent, global::PassKit.PKPaymentRequestPaymentMethodUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::PassKit.PKPaymentRequestPaymentMethodUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidSelectPaymentMethod2 += x, x => _data.DidSelectPaymentMethod2 -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidSelectShippingContact2 => global::System.Reactive.Linq.Observable.FromEvent, global::PassKit.PKPaymentRequestShippingContactUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::PassKit.PKPaymentRequestShippingContactUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidSelectShippingContact2 += x, x => _data.DidSelectShippingContact2 -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidSelectShippingMethod2 => global::System.Reactive.Linq.Observable.FromEvent, global::PassKit.PKPaymentRequestShippingMethodUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::PassKit.PKPaymentRequestShippingMethodUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidSelectShippingMethod2 += x, x => _data.DidSelectShippingMethod2 -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PaymentAuthorizationViewControllerDidFinish => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PaymentAuthorizationViewControllerDidFinish += x, x => _data.PaymentAuthorizationViewControllerDidFinish -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillAuthorizePayment => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillAuthorizePayment += x, x => _data.WillAuthorizePayment -= x); + } +} + +namespace PdfKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPdfDocumentEvents Events(this global::PdfKit.PdfDocument item) => new RxPdfDocumentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPdfViewEvents Events(this global::PdfKit.PdfView item) => new RxPdfViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPdfDocumentEvents + { + private readonly global::PdfKit.PdfDocument _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPdfDocumentEvents(global::PdfKit.PdfDocument data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidBeginDocumentFind => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidBeginDocumentFind += x, x => _data.DidBeginDocumentFind -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidMatchString => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidMatchString += x, x => _data.DidMatchString -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUnlock => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUnlock += x, x => _data.DidUnlock -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FindFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FindFinished += x, x => _data.FindFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MatchFound => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MatchFound += x, x => _data.MatchFound -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageFindFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageFindFinished += x, x => _data.PageFindFinished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PageFindStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PageFindStarted += x, x => _data.PageFindStarted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxPdfViewEvents + { + private readonly global::PdfKit.PdfView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxPdfViewEvents(global::PdfKit.PdfView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OpenPdf => global::System.Reactive.Linq.Observable.FromEvent, global::PdfKit.PdfViewActionEventArgs>(eventHandler => + { + void Handler(object sender, global::PdfKit.PdfViewActionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OpenPdf += x, x => _data.OpenPdf -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PerformFind => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PerformFind += x, x => _data.PerformFind -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PerformGoToPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PerformGoToPage += x, x => _data.PerformGoToPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PerformPrint => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PerformPrint += x, x => _data.PerformPrint -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillClickOnLink => global::System.Reactive.Linq.Observable.FromEvent, global::PdfKit.PdfViewUrlEventArgs>(eventHandler => + { + void Handler(object sender, global::PdfKit.PdfViewUrlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillClickOnLink += x, x => _data.WillClickOnLink -= x); + } +} + +namespace QTKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxQTCaptureDecompressedVideoOutputEvents Events(this global::QTKit.QTCaptureDecompressedVideoOutput item) => new RxQTCaptureDecompressedVideoOutputEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxQTCaptureFileOutputEvents Events(this global::QTKit.QTCaptureFileOutput item) => new RxQTCaptureFileOutputEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxQTCaptureDecompressedVideoOutputEvents + { + private readonly global::QTKit.QTCaptureDecompressedVideoOutput _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxQTCaptureDecompressedVideoOutputEvents(global::QTKit.QTCaptureDecompressedVideoOutput data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidDropVideoFrame => global::System.Reactive.Linq.Observable.FromEvent, global::QTKit.QTCaptureVideoDroppedEventArgs>(eventHandler => + { + void Handler(object sender, global::QTKit.QTCaptureVideoDroppedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidDropVideoFrame += x, x => _data.DidDropVideoFrame -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidOutputVideoFrame => global::System.Reactive.Linq.Observable.FromEvent, global::QTKit.QTCaptureVideoFrameEventArgs>(eventHandler => + { + void Handler(object sender, global::QTKit.QTCaptureVideoFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidOutputVideoFrame += x, x => _data.DidOutputVideoFrame -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxQTCaptureFileOutputEvents + { + private readonly global::QTKit.QTCaptureFileOutput _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxQTCaptureFileOutputEvents(global::QTKit.QTCaptureFileOutput data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinishRecording => global::System.Reactive.Linq.Observable.FromEvent, global::QTKit.QTCaptureFileErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::QTKit.QTCaptureFileErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinishRecording += x, x => _data.DidFinishRecording -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidOutputSampleBuffer => global::System.Reactive.Linq.Observable.FromEvent, global::QTKit.QTCaptureFileSampleEventArgs>(eventHandler => + { + void Handler(object sender, global::QTKit.QTCaptureFileSampleEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidOutputSampleBuffer += x, x => _data.DidOutputSampleBuffer -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidPauseRecording => global::System.Reactive.Linq.Observable.FromEvent, global::QTKit.QTCaptureFileUrlEventArgs>(eventHandler => + { + void Handler(object sender, global::QTKit.QTCaptureFileUrlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidPauseRecording += x, x => _data.DidPauseRecording -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidResumeRecording => global::System.Reactive.Linq.Observable.FromEvent, global::QTKit.QTCaptureFileUrlEventArgs>(eventHandler => + { + void Handler(object sender, global::QTKit.QTCaptureFileUrlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidResumeRecording += x, x => _data.DidResumeRecording -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidStartRecording => global::System.Reactive.Linq.Observable.FromEvent, global::QTKit.QTCaptureFileUrlEventArgs>(eventHandler => + { + void Handler(object sender, global::QTKit.QTCaptureFileUrlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidStartRecording += x, x => _data.DidStartRecording -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MustChangeOutputFile => global::System.Reactive.Linq.Observable.FromEvent, global::QTKit.QTCaptureFileErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::QTKit.QTCaptureFileErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MustChangeOutputFile += x, x => _data.MustChangeOutputFile -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillFinishRecording => global::System.Reactive.Linq.Observable.FromEvent, global::QTKit.QTCaptureFileErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::QTKit.QTCaptureFileErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillFinishRecording += x, x => _data.WillFinishRecording -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillStartRecording => global::System.Reactive.Linq.Observable.FromEvent, global::QTKit.QTCaptureFileUrlEventArgs>(eventHandler => + { + void Handler(object sender, global::QTKit.QTCaptureFileUrlEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillStartRecording += x, x => _data.WillStartRecording -= x); + } +} + +namespace SceneKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSCNPhysicsWorldEvents Events(this global::SceneKit.SCNPhysicsWorld item) => new RxSCNPhysicsWorldEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSCNPhysicsWorldEvents + { + private readonly global::SceneKit.SCNPhysicsWorld _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSCNPhysicsWorldEvents(global::SceneKit.SCNPhysicsWorld data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidBeginContact => global::System.Reactive.Linq.Observable.FromEvent, global::SceneKit.SCNPhysicsContactEventArgs>(eventHandler => + { + void Handler(object sender, global::SceneKit.SCNPhysicsContactEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidBeginContact += x, x => _data.DidBeginContact -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEndContact => global::System.Reactive.Linq.Observable.FromEvent, global::SceneKit.SCNPhysicsContactEventArgs>(eventHandler => + { + void Handler(object sender, global::SceneKit.SCNPhysicsContactEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEndContact += x, x => _data.DidEndContact -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateContact => global::System.Reactive.Linq.Observable.FromEvent, global::SceneKit.SCNPhysicsContactEventArgs>(eventHandler => + { + void Handler(object sender, global::SceneKit.SCNPhysicsContactEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateContact += x, x => _data.DidUpdateContact -= x); + } +} + +namespace SpriteKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSKPhysicsWorldEvents Events(this global::SpriteKit.SKPhysicsWorld item) => new RxSKPhysicsWorldEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSKPhysicsWorldEvents + { + private readonly global::SpriteKit.SKPhysicsWorld _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSKPhysicsWorldEvents(global::SpriteKit.SKPhysicsWorld data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidBeginContact => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidBeginContact += x, x => _data.DidBeginContact -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEndContact => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEndContact += x, x => _data.DidEndContact -= x); + } +} + +namespace StoreKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSKProductsRequestEvents Events(this global::StoreKit.SKProductsRequest item) => new RxSKProductsRequestEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSKRequestEvents Events(this global::StoreKit.SKRequest item) => new RxSKRequestEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSKStoreProductViewControllerEvents Events(this global::StoreKit.SKStoreProductViewController item) => new RxSKStoreProductViewControllerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSKProductsRequestEvents : global::StoreKit.RxSKRequestEvents + { + private readonly global::StoreKit.SKProductsRequest _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSKProductsRequestEvents(global::StoreKit.SKProductsRequest data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReceivedResponse => global::System.Reactive.Linq.Observable.FromEvent, global::StoreKit.SKProductsRequestResponseEventArgs>(eventHandler => + { + void Handler(object sender, global::StoreKit.SKProductsRequestResponseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReceivedResponse += x, x => _data.ReceivedResponse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSKRequestEvents + { + private readonly global::StoreKit.SKRequest _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSKRequestEvents(global::StoreKit.SKRequest data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestFailed => global::System.Reactive.Linq.Observable.FromEvent, global::StoreKit.SKRequestErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::StoreKit.SKRequestErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestFailed += x, x => _data.RequestFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestFinished += x, x => _data.RequestFinished -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSKStoreProductViewControllerEvents + { + private readonly global::StoreKit.SKStoreProductViewController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSKStoreProductViewControllerEvents(global::StoreKit.SKStoreProductViewController data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finished += x, x => _data.Finished -= x); + } +} + +namespace WebKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxWebViewEvents Events(this global::WebKit.WebView item) => new RxWebViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxWebViewEvents + { + private readonly global::WebKit.WebView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxWebViewEvents(global::WebKit.WebView data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanceledClientRedirect => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFrameEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanceledClientRedirect += x, x => _data.CanceledClientRedirect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ChangedLocationWithinPage => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFrameEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ChangedLocationWithinPage += x, x => _data.ChangedLocationWithinPage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClearedWindowObject => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFrameScriptFrameEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFrameScriptFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClearedWindowObject += x, x => _data.ClearedWindowObject -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CommitedLoad => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFrameEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CommitedLoad += x, x => _data.CommitedLoad -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecidePolicyForMimeType => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebMimeTypePolicyEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebMimeTypePolicyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecidePolicyForMimeType += x, x => _data.DecidePolicyForMimeType -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecidePolicyForNavigation => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebNavigationPolicyEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebNavigationPolicyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecidePolicyForNavigation += x, x => _data.DecidePolicyForNavigation -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DecidePolicyForNewWindow => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebNewWindowPolicyEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebNewWindowPolicyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DecidePolicyForNewWindow += x, x => _data.DecidePolicyForNewWindow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidCreateJavaScriptContext => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFrameJavaScriptContextEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFrameJavaScriptContextEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidCreateJavaScriptContext += x, x => _data.DidCreateJavaScriptContext -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FailedLoadWithError => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFrameErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFrameErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FailedLoadWithError += x, x => _data.FailedLoadWithError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FailedProvisionalLoad => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFrameErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFrameErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FailedProvisionalLoad += x, x => _data.FailedProvisionalLoad -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FinishedLoad => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFrameEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FinishedLoad += x, x => _data.FinishedLoad -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OnCancelledAuthenticationChallenge => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebResourceCancelledChallengeEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebResourceCancelledChallengeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OnCancelledAuthenticationChallenge += x, x => _data.OnCancelledAuthenticationChallenge -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OnFailedLoading => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebResourceErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebResourceErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OnFailedLoading += x, x => _data.OnFailedLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OnFinishedLoading => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebResourceCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebResourceCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OnFinishedLoading += x, x => _data.OnFinishedLoading -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OnPlugInFailed => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebResourcePluginErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebResourcePluginErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OnPlugInFailed += x, x => _data.OnPlugInFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OnReceivedAuthenticationChallenge => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebResourceAuthenticationChallengeEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebResourceAuthenticationChallengeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OnReceivedAuthenticationChallenge += x, x => _data.OnReceivedAuthenticationChallenge -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OnReceivedContentLength => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebResourceReceivedContentLengthEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebResourceReceivedContentLengthEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OnReceivedContentLength += x, x => _data.OnReceivedContentLength -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OnReceivedResponse => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebResourceReceivedResponseEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebResourceReceivedResponseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OnReceivedResponse += x, x => _data.OnReceivedResponse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReceivedIcon => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFrameImageEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFrameImageEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReceivedIcon += x, x => _data.ReceivedIcon -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReceivedServerRedirectForProvisionalLoad => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFrameEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReceivedServerRedirectForProvisionalLoad += x, x => _data.ReceivedServerRedirectForProvisionalLoad -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReceivedTitle => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFrameTitleEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFrameTitleEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReceivedTitle += x, x => _data.ReceivedTitle -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StartedProvisionalLoad => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFrameEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StartedProvisionalLoad += x, x => _data.StartedProvisionalLoad -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UIClose => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UIClose += x, x => _data.UIClose -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UIDrawFooterInRect => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewFooterEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewFooterEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UIDrawFooterInRect += x, x => _data.UIDrawFooterInRect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UIDrawHeaderInRect => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewHeaderEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewHeaderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UIDrawHeaderInRect += x, x => _data.UIDrawHeaderInRect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UIFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UIFocus += x, x => _data.UIFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UIMakeFirstResponder => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewResponderEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewResponderEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UIMakeFirstResponder += x, x => _data.UIMakeFirstResponder -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UIMouseDidMoveOverElement => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewMouseMovedEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewMouseMovedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UIMouseDidMoveOverElement += x, x => _data.UIMouseDidMoveOverElement -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UIPrintFrameView => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewPrintEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewPrintEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UIPrintFrameView += x, x => _data.UIPrintFrameView -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UIRunJavaScriptAlertPanel => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewJavaScriptEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewJavaScriptEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UIRunJavaScriptAlertPanel += x, x => _data.UIRunJavaScriptAlertPanel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UIRunJavaScriptAlertPanelMessage => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewJavaScriptFrameEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewJavaScriptFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UIRunJavaScriptAlertPanelMessage += x, x => _data.UIRunJavaScriptAlertPanelMessage -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UIRunModal => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UIRunModal += x, x => _data.UIRunModal -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UIRunOpenPanelForFileButton => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewRunOpenPanelEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewRunOpenPanelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UIRunOpenPanelForFileButton += x, x => _data.UIRunOpenPanelForFileButton -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UISetContentRect => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewContentEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewContentEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UISetContentRect += x, x => _data.UISetContentRect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UISetFrame => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewFrameEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UISetFrame += x, x => _data.UISetFrame -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UISetResizable => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewResizableEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewResizableEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UISetResizable += x, x => _data.UISetResizable -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UISetStatusBarVisible => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewStatusBarEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewStatusBarEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UISetStatusBarVisible += x, x => _data.UISetStatusBarVisible -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UISetStatusText => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewStatusTextEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewStatusTextEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UISetStatusText += x, x => _data.UISetStatusText -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UISetToolbarsVisible => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewToolBarsEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewToolBarsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UISetToolbarsVisible += x, x => _data.UISetToolbarsVisible -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UIShow => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UIShow += x, x => _data.UIShow -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UIUnfocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UIUnfocus += x, x => _data.UIUnfocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UIWillPerformDragDestination => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewDragEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UIWillPerformDragDestination += x, x => _data.UIWillPerformDragDestination -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UIWillPerformDragSource => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebViewPerformDragEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebViewPerformDragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UIWillPerformDragSource += x, x => _data.UIWillPerformDragSource -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnableToImplementPolicy => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFailureToImplementPolicyEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFailureToImplementPolicyEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnableToImplementPolicy += x, x => _data.UnableToImplementPolicy -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillCloseFrame => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFrameEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFrameEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillCloseFrame += x, x => _data.WillCloseFrame -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillPerformClientRedirect => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFrameClientRedirectEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFrameClientRedirectEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillPerformClientRedirect += x, x => _data.WillPerformClientRedirect -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WindowScriptObjectAvailable => global::System.Reactive.Linq.Observable.FromEvent, global::WebKit.WebFrameScriptObjectEventArgs>(eventHandler => + { + void Handler(object sender, global::WebKit.WebFrameScriptObjectEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WindowScriptObjectAvailable += x, x => _data.WindowScriptObjectAvailable -= x); + } +} + +namespace ObjCRuntime +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RuntimeAssemblyRegistration => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::ObjCRuntime.AssemblyRegistrationEventArgs args) => eventHandler(args); + return Handler; + }, x => global::ObjCRuntime.Runtime.AssemblyRegistration += x, x => global::ObjCRuntime.Runtime.AssemblyRegistration -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RuntimeMarshalManagedException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::ObjCRuntime.MarshalManagedExceptionEventArgs args) => eventHandler(args); + return Handler; + }, x => global::ObjCRuntime.Runtime.MarshalManagedException += x, x => global::ObjCRuntime.Runtime.MarshalManagedException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RuntimeMarshalObjectiveCException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::ObjCRuntime.MarshalObjectiveCExceptionEventArgs args) => eventHandler(args); + return Handler; + }, x => global::ObjCRuntime.Runtime.MarshalObjectiveCException += x, x => global::ObjCRuntime.Runtime.MarshalObjectiveCException -= x); + } +} + +namespace AppKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSAnimationDelegateRx : global::AppKit.NSAnimationDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _animationDidEnd = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSAnimation animation, float progress)> _animationDidReachProgressMark = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSAnimation animation, float progress)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _animationDidStop = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable AnimationDidEndObs => _animationDidEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSAnimation animation, float progress)> AnimationDidReachProgressMarkObs => _animationDidReachProgressMark; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable AnimationDidStopObs => _animationDidStop; + /// + public override void AnimationDidEnd(global::AppKit.NSAnimation animation) => _animationDidEnd.OnNext(animation); + /// + public override void AnimationDidReachProgressMark(global::AppKit.NSAnimation animation, float progress) => _animationDidReachProgressMark.OnNext((animation, progress)); + /// + public override void AnimationDidStop(global::AppKit.NSAnimation animation) => _animationDidStop.OnNext(animation); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSApplicationDelegateRx : global::AppKit.NSApplicationDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication app, global::Foundation.NSCoder state)> _decodedRestorableState = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication app, global::Foundation.NSCoder state)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeActive = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinishLaunching = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didHide = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didResignActive = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUnhide = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdate = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication application, string userActivityType, global::Foundation.NSError error)> _failedToContinueUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication application, string userActivityType, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication application, global::Foundation.NSError error)> _failedToRegisterForRemoteNotifications = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication application, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication sender, global::System.String[] filenames)> _openFiles = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication sender, global::System.String[] filenames)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication application, global::Foundation.NSUrl[] urls)> _openUrls = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication application, global::Foundation.NSUrl[] urls)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _orderFrontStandardAboutPanel = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _orderFrontStandardAboutPanelWithOptions = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication application, global::Foundation.NSDictionary userInfo)> _receivedRemoteNotification = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication application, global::Foundation.NSDictionary userInfo)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication application, global::Foundation.NSData deviceToken)> _registeredForRemoteNotifications = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication application, global::Foundation.NSData deviceToken)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::System.String[] sendTypes, global::System.String[] returnTypes)> _registerServicesMenu = new Pharmacist.Common.SingleAwaitSubject<(global::System.String[] sendTypes, global::System.String[] returnTypes)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _screenParametersChanged = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication application, global::Foundation.NSUserActivity userActivity)> _updatedUserActivity = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication application, global::Foundation.NSUserActivity userActivity)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication application, global::CloudKit.CKShareMetadata metadata)> _userDidAcceptCloudKitShare = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication application, global::CloudKit.CKShareMetadata metadata)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willBecomeActive = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication app, global::Foundation.NSCoder encoder)> _willEncodeRestorableState = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSApplication app, global::Foundation.NSCoder encoder)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willFinishLaunching = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willHide = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willResignActive = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willTerminate = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willUnhide = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willUpdate = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSApplication app, global::Foundation.NSCoder state)> DecodedRestorableStateObs => _decodedRestorableState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeActiveObs => _didBecomeActive; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishLaunchingObs => _didFinishLaunching; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidHideObs => _didHide; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidResignActiveObs => _didResignActive; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUnhideObs => _didUnhide; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateObs => _didUpdate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSApplication application, string userActivityType, global::Foundation.NSError error)> FailedToContinueUserActivityObs => _failedToContinueUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSApplication application, global::Foundation.NSError error)> FailedToRegisterForRemoteNotificationsObs => _failedToRegisterForRemoteNotifications; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSApplication sender, global::System.String[] filenames)> OpenFilesObs => _openFiles; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSApplication application, global::Foundation.NSUrl[] urls)> OpenUrlsObs => _openUrls; + /// + /// Gets an observable which signals when the method is invoked. + /// + [global::System.ObsoleteAttribute("Use the 'OrderFrontStandardAboutPanel2' on NSApplication.", false)] + public global::System.IObservable OrderFrontStandardAboutPanelObs => _orderFrontStandardAboutPanel; + /// + /// Gets an observable which signals when the method is invoked. + /// + [global::System.ObsoleteAttribute("Use the 'OrderFrontStandardAboutPanelWithOptions2' on NSApplication.", false)] + public global::System.IObservable OrderFrontStandardAboutPanelWithOptionsObs => _orderFrontStandardAboutPanelWithOptions; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSApplication application, global::Foundation.NSDictionary userInfo)> ReceivedRemoteNotificationObs => _receivedRemoteNotification; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSApplication application, global::Foundation.NSData deviceToken)> RegisteredForRemoteNotificationsObs => _registeredForRemoteNotifications; + /// + /// Gets an observable which signals when the method is invoked. + /// + [global::System.ObsoleteAttribute("Use the 'RegisterServicesMenu2' on NSApplication.", false)] + public global::System.IObservable<(global::System.String[] sendTypes, global::System.String[] returnTypes)> RegisterServicesMenuObs => _registerServicesMenu; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ScreenParametersChangedObs => _screenParametersChanged; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSApplication application, global::Foundation.NSUserActivity userActivity)> UpdatedUserActivityObs => _updatedUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSApplication application, global::CloudKit.CKShareMetadata metadata)> UserDidAcceptCloudKitShareObs => _userDidAcceptCloudKitShare; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillBecomeActiveObs => _willBecomeActive; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSApplication app, global::Foundation.NSCoder encoder)> WillEncodeRestorableStateObs => _willEncodeRestorableState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillFinishLaunchingObs => _willFinishLaunching; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillHideObs => _willHide; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillResignActiveObs => _willResignActive; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillTerminateObs => _willTerminate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillUnhideObs => _willUnhide; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillUpdateObs => _willUpdate; + /// + public override void DecodedRestorableState(global::AppKit.NSApplication app, global::Foundation.NSCoder state) => _decodedRestorableState.OnNext((app, state)); + /// + public override void DidBecomeActive(global::Foundation.NSNotification notification) => _didBecomeActive.OnNext(notification); + /// + public override void DidFinishLaunching(global::Foundation.NSNotification notification) => _didFinishLaunching.OnNext(notification); + /// + public override void DidHide(global::Foundation.NSNotification notification) => _didHide.OnNext(notification); + /// + public override void DidResignActive(global::Foundation.NSNotification notification) => _didResignActive.OnNext(notification); + /// + public override void DidUnhide(global::Foundation.NSNotification notification) => _didUnhide.OnNext(notification); + /// + public override void DidUpdate(global::Foundation.NSNotification notification) => _didUpdate.OnNext(notification); + /// + public override void FailedToContinueUserActivity(global::AppKit.NSApplication application, string userActivityType, global::Foundation.NSError error) => _failedToContinueUserActivity.OnNext((application, userActivityType, error)); + /// + public override void FailedToRegisterForRemoteNotifications(global::AppKit.NSApplication application, global::Foundation.NSError error) => _failedToRegisterForRemoteNotifications.OnNext((application, error)); + /// + public override void OpenFiles(global::AppKit.NSApplication sender, global::System.String[] filenames) => _openFiles.OnNext((sender, filenames)); + /// + public override void OpenUrls(global::AppKit.NSApplication application, global::Foundation.NSUrl[] urls) => _openUrls.OnNext((application, urls)); + /// + [global::System.ObsoleteAttribute("Use the 'OrderFrontStandardAboutPanel2' on NSApplication.", false)] + public override void OrderFrontStandardAboutPanel(global::Foundation.NSObject sender) => _orderFrontStandardAboutPanel.OnNext(sender); + /// + [global::System.ObsoleteAttribute("Use the 'OrderFrontStandardAboutPanelWithOptions2' on NSApplication.", false)] + public override void OrderFrontStandardAboutPanelWithOptions(global::Foundation.NSDictionary optionsDictionary) => _orderFrontStandardAboutPanelWithOptions.OnNext(optionsDictionary); + /// + public override void ReceivedRemoteNotification(global::AppKit.NSApplication application, global::Foundation.NSDictionary userInfo) => _receivedRemoteNotification.OnNext((application, userInfo)); + /// + public override void RegisteredForRemoteNotifications(global::AppKit.NSApplication application, global::Foundation.NSData deviceToken) => _registeredForRemoteNotifications.OnNext((application, deviceToken)); + /// + [global::System.ObsoleteAttribute("Use the 'RegisterServicesMenu2' on NSApplication.", false)] + public override void RegisterServicesMenu(global::System.String[] sendTypes, global::System.String[] returnTypes) => _registerServicesMenu.OnNext((sendTypes, returnTypes)); + /// + public override void ScreenParametersChanged(global::Foundation.NSNotification notification) => _screenParametersChanged.OnNext(notification); + /// + public override void UpdatedUserActivity(global::AppKit.NSApplication application, global::Foundation.NSUserActivity userActivity) => _updatedUserActivity.OnNext((application, userActivity)); + /// + public override void UserDidAcceptCloudKitShare(global::AppKit.NSApplication application, global::CloudKit.CKShareMetadata metadata) => _userDidAcceptCloudKitShare.OnNext((application, metadata)); + /// + public override void WillBecomeActive(global::Foundation.NSNotification notification) => _willBecomeActive.OnNext(notification); + /// + public override void WillEncodeRestorableState(global::AppKit.NSApplication app, global::Foundation.NSCoder encoder) => _willEncodeRestorableState.OnNext((app, encoder)); + /// + public override void WillFinishLaunching(global::Foundation.NSNotification notification) => _willFinishLaunching.OnNext(notification); + /// + public override void WillHide(global::Foundation.NSNotification notification) => _willHide.OnNext(notification); + /// + public override void WillResignActive(global::Foundation.NSNotification notification) => _willResignActive.OnNext(notification); + /// + public override void WillTerminate(global::Foundation.NSNotification notification) => _willTerminate.OnNext(notification); + /// + public override void WillUnhide(global::Foundation.NSNotification notification) => _willUnhide.OnNext(notification); + /// + public override void WillUpdate(global::Foundation.NSNotification notification) => _willUpdate.OnNext(notification); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSBrowserDelegateRx : global::AppKit.NSBrowserDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _columnConfigurationDidChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSBrowser sender, global::System.nint column, global::AppKit.NSMatrix matrix)> _createRowsForColumn = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSBrowser sender, global::System.nint column, global::AppKit.NSMatrix matrix)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSBrowser browser, global::System.nint oldLastColumn, global::System.nint toColumn)> _didChangeLastColumn = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSBrowser browser, global::System.nint oldLastColumn, global::System.nint toColumn)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didScroll = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSBrowser browser, global::Foundation.NSObject obj, global::Foundation.NSObject item)> _setObjectValue = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSBrowser browser, global::Foundation.NSObject obj, global::Foundation.NSObject item)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSBrowser sender, global::Foundation.NSObject cell, global::System.nint row, global::System.nint column)> _willDisplayCell = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSBrowser sender, global::Foundation.NSObject cell, global::System.nint row, global::System.nint column)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willScroll = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ColumnConfigurationDidChangeObs => _columnConfigurationDidChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSBrowser sender, global::System.nint column, global::AppKit.NSMatrix matrix)> CreateRowsForColumnObs => _createRowsForColumn; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSBrowser browser, global::System.nint oldLastColumn, global::System.nint toColumn)> DidChangeLastColumnObs => _didChangeLastColumn; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidScrollObs => _didScroll; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSBrowser browser, global::Foundation.NSObject obj, global::Foundation.NSObject item)> SetObjectValueObs => _setObjectValue; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSBrowser sender, global::Foundation.NSObject cell, global::System.nint row, global::System.nint column)> WillDisplayCellObs => _willDisplayCell; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillScrollObs => _willScroll; + /// + public override void ColumnConfigurationDidChange(global::Foundation.NSNotification notification) => _columnConfigurationDidChange.OnNext(notification); + /// + public override void CreateRowsForColumn(global::AppKit.NSBrowser sender, global::System.nint column, global::AppKit.NSMatrix matrix) => _createRowsForColumn.OnNext((sender, column, matrix)); + /// + public override void DidChangeLastColumn(global::AppKit.NSBrowser browser, global::System.nint oldLastColumn, global::System.nint toColumn) => _didChangeLastColumn.OnNext((browser, oldLastColumn, toColumn)); + /// + public override void DidScroll(global::AppKit.NSBrowser sender) => _didScroll.OnNext(sender); + /// + public override void SetObjectValue(global::AppKit.NSBrowser browser, global::Foundation.NSObject obj, global::Foundation.NSObject item) => _setObjectValue.OnNext((browser, obj, item)); + /// + public override void WillDisplayCell(global::AppKit.NSBrowser sender, global::Foundation.NSObject cell, global::System.nint row, global::System.nint column) => _willDisplayCell.OnNext((sender, cell, row, column)); + /// + public override void WillScroll(global::AppKit.NSBrowser sender) => _willScroll.OnNext(sender); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSCandidateListTouchBarItemDelegateRx : global::AppKit.NSCandidateListTouchBarItemDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCandidateListTouchBarItem anItem, global::System.nint index)> _beginSelectingCandidate = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCandidateListTouchBarItem anItem, global::System.nint index)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCandidateListTouchBarItem anItem, bool isVisible)> _changedCandidateListVisibility = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCandidateListTouchBarItem anItem, bool isVisible)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCandidateListTouchBarItem anItem, global::System.nint previousIndex, global::System.nint index)> _changeSelectionFromCandidate = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCandidateListTouchBarItem anItem, global::System.nint previousIndex, global::System.nint index)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCandidateListTouchBarItem anItem, global::System.nint index)> _endSelectingCandidate = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCandidateListTouchBarItem anItem, global::System.nint index)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSCandidateListTouchBarItem anItem, global::System.nint index)> BeginSelectingCandidateObs => _beginSelectingCandidate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSCandidateListTouchBarItem anItem, bool isVisible)> ChangedCandidateListVisibilityObs => _changedCandidateListVisibility; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSCandidateListTouchBarItem anItem, global::System.nint previousIndex, global::System.nint index)> ChangeSelectionFromCandidateObs => _changeSelectionFromCandidate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSCandidateListTouchBarItem anItem, global::System.nint index)> EndSelectingCandidateObs => _endSelectingCandidate; + /// + public override void BeginSelectingCandidate(global::AppKit.NSCandidateListTouchBarItem anItem, global::System.nint index) => _beginSelectingCandidate.OnNext((anItem, index)); + /// + public override void ChangedCandidateListVisibility(global::AppKit.NSCandidateListTouchBarItem anItem, bool isVisible) => _changedCandidateListVisibility.OnNext((anItem, isVisible)); + /// + public override void ChangeSelectionFromCandidate(global::AppKit.NSCandidateListTouchBarItem anItem, global::System.nint previousIndex, global::System.nint index) => _changeSelectionFromCandidate.OnNext((anItem, previousIndex, index)); + /// + public override void EndSelectingCandidate(global::AppKit.NSCandidateListTouchBarItem anItem, global::System.nint index) => _endSelectingCandidate.OnNext((anItem, index)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSCloudSharingServiceDelegateRx : global::AppKit.NSCloudSharingServiceDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items, global::Foundation.NSError error)> _completed = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingService sharingService, global::CloudKit.CKShare share)> _saved = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingService sharingService, global::CloudKit.CKShare share)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingService sharingService, global::CloudKit.CKShare share)> _stopped = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingService sharingService, global::CloudKit.CKShare share)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items, global::Foundation.NSError error)> CompletedObs => _completed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSharingService sharingService, global::CloudKit.CKShare share)> SavedObs => _saved; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSharingService sharingService, global::CloudKit.CKShare share)> StoppedObs => _stopped; + /// + public override void Completed(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items, global::Foundation.NSError error) => _completed.OnNext((sharingService, items, error)); + /// + public override void Saved(global::AppKit.NSSharingService sharingService, global::CloudKit.CKShare share) => _saved.OnNext((sharingService, share)); + /// + public override void Stopped(global::AppKit.NSSharingService sharingService, global::CloudKit.CKShare share) => _stopped.OnNext((sharingService, share)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSCollectionViewDelegateRx : global::AppKit.NSCollectionViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSCollectionViewItem item, global::Foundation.NSIndexPath indexPath)> _displayingItemEnded = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSCollectionViewItem item, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSView view, string elementKind, global::Foundation.NSIndexPath indexPath)> _displayingSupplementaryViewEnded = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSView view, string elementKind, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSDraggingSession draggingSession, global::CoreGraphics.CGPoint screenPoint, global::AppKit.NSDragOperation dragOperation)> _draggingSessionEnded = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSDraggingSession draggingSession, global::CoreGraphics.CGPoint screenPoint, global::AppKit.NSDragOperation dragOperation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSDraggingSession session, global::CoreGraphics.CGPoint screenPoint, global::Foundation.NSSet indexPaths)> _draggingSessionWillBegin = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSDraggingSession session, global::CoreGraphics.CGPoint screenPoint, global::Foundation.NSSet indexPaths)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::Foundation.NSSet indexPaths, global::AppKit.NSCollectionViewItemHighlightState highlightState)> _itemsChanged = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::Foundation.NSSet indexPaths, global::AppKit.NSCollectionViewItemHighlightState highlightState)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::Foundation.NSSet indexPaths)> _itemsDeselected = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::Foundation.NSSet indexPaths)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::Foundation.NSSet indexPaths)> _itemsSelected = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::Foundation.NSSet indexPaths)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSDraggingInfo draggingInfo)> _updateDraggingItemsForDrag = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSDraggingInfo draggingInfo)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSCollectionViewItem item, global::Foundation.NSIndexPath indexPath)> _willDisplayItem = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSCollectionViewItem item, global::Foundation.NSIndexPath indexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSView view, global::Foundation.NSString elementKind, global::Foundation.NSIndexPath indexPath)> _willDisplaySupplementaryView = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSView view, global::Foundation.NSString elementKind, global::Foundation.NSIndexPath indexPath)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSCollectionViewItem item, global::Foundation.NSIndexPath indexPath)> DisplayingItemEndedObs => _displayingItemEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSView view, string elementKind, global::Foundation.NSIndexPath indexPath)> DisplayingSupplementaryViewEndedObs => _displayingSupplementaryViewEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSDraggingSession draggingSession, global::CoreGraphics.CGPoint screenPoint, global::AppKit.NSDragOperation dragOperation)> DraggingSessionEndedObs => _draggingSessionEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSDraggingSession session, global::CoreGraphics.CGPoint screenPoint, global::Foundation.NSSet indexPaths)> DraggingSessionWillBeginObs => _draggingSessionWillBegin; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSCollectionView collectionView, global::Foundation.NSSet indexPaths, global::AppKit.NSCollectionViewItemHighlightState highlightState)> ItemsChangedObs => _itemsChanged; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSCollectionView collectionView, global::Foundation.NSSet indexPaths)> ItemsDeselectedObs => _itemsDeselected; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSCollectionView collectionView, global::Foundation.NSSet indexPaths)> ItemsSelectedObs => _itemsSelected; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSDraggingInfo draggingInfo)> UpdateDraggingItemsForDragObs => _updateDraggingItemsForDrag; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSCollectionViewItem item, global::Foundation.NSIndexPath indexPath)> WillDisplayItemObs => _willDisplayItem; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSCollectionView collectionView, global::AppKit.NSView view, global::Foundation.NSString elementKind, global::Foundation.NSIndexPath indexPath)> WillDisplaySupplementaryViewObs => _willDisplaySupplementaryView; + /// + public override void DisplayingItemEnded(global::AppKit.NSCollectionView collectionView, global::AppKit.NSCollectionViewItem item, global::Foundation.NSIndexPath indexPath) => _displayingItemEnded.OnNext((collectionView, item, indexPath)); + /// + public override void DisplayingSupplementaryViewEnded(global::AppKit.NSCollectionView collectionView, global::AppKit.NSView view, string elementKind, global::Foundation.NSIndexPath indexPath) => _displayingSupplementaryViewEnded.OnNext((collectionView, view, elementKind, indexPath)); + /// + public override void DraggingSessionEnded(global::AppKit.NSCollectionView collectionView, global::AppKit.NSDraggingSession draggingSession, global::CoreGraphics.CGPoint screenPoint, global::AppKit.NSDragOperation dragOperation) => _draggingSessionEnded.OnNext((collectionView, draggingSession, screenPoint, dragOperation)); + /// + public override void DraggingSessionWillBegin(global::AppKit.NSCollectionView collectionView, global::AppKit.NSDraggingSession session, global::CoreGraphics.CGPoint screenPoint, global::Foundation.NSSet indexPaths) => _draggingSessionWillBegin.OnNext((collectionView, session, screenPoint, indexPaths)); + /// + public override void ItemsChanged(global::AppKit.NSCollectionView collectionView, global::Foundation.NSSet indexPaths, global::AppKit.NSCollectionViewItemHighlightState highlightState) => _itemsChanged.OnNext((collectionView, indexPaths, highlightState)); + /// + public override void ItemsDeselected(global::AppKit.NSCollectionView collectionView, global::Foundation.NSSet indexPaths) => _itemsDeselected.OnNext((collectionView, indexPaths)); + /// + public override void ItemsSelected(global::AppKit.NSCollectionView collectionView, global::Foundation.NSSet indexPaths) => _itemsSelected.OnNext((collectionView, indexPaths)); + /// + public override void UpdateDraggingItemsForDrag(global::AppKit.NSCollectionView collectionView, global::AppKit.NSDraggingInfo draggingInfo) => _updateDraggingItemsForDrag.OnNext((collectionView, draggingInfo)); + /// + public override void WillDisplayItem(global::AppKit.NSCollectionView collectionView, global::AppKit.NSCollectionViewItem item, global::Foundation.NSIndexPath indexPath) => _willDisplayItem.OnNext((collectionView, item, indexPath)); + /// + public override void WillDisplaySupplementaryView(global::AppKit.NSCollectionView collectionView, global::AppKit.NSView view, global::Foundation.NSString elementKind, global::Foundation.NSIndexPath indexPath) => _willDisplaySupplementaryView.OnNext((collectionView, view, elementKind, indexPath)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSComboBoxDelegateRx : global::AppKit.NSComboBoxDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _selectionChanged = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _selectionIsChanging = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willDismiss = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willPopUp = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SelectionChangedObs => _selectionChanged; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SelectionIsChangingObs => _selectionIsChanging; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillDismissObs => _willDismiss; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillPopUpObs => _willPopUp; + /// + public override void SelectionChanged(global::Foundation.NSNotification notification) => _selectionChanged.OnNext(notification); + /// + public override void SelectionIsChanging(global::Foundation.NSNotification notification) => _selectionIsChanging.OnNext(notification); + /// + public override void WillDismiss(global::Foundation.NSNotification notification) => _willDismiss.OnNext(notification); + /// + public override void WillPopUp(global::Foundation.NSNotification notification) => _willPopUp.OnNext(notification); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSControlTextEditingDelegateRx : global::AppKit.NSControlTextEditingDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _controlTextDidBeginEditing = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _controlTextDidChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _controlTextDidEndEditing = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSControl control, string str, string error)> _didFailToValidatePartialString = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSControl control, string str, string error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ControlTextDidBeginEditingObs => _controlTextDidBeginEditing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ControlTextDidChangeObs => _controlTextDidChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ControlTextDidEndEditingObs => _controlTextDidEndEditing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSControl control, string str, string error)> DidFailToValidatePartialStringObs => _didFailToValidatePartialString; + /// + public override void ControlTextDidBeginEditing(global::Foundation.NSNotification obj) => _controlTextDidBeginEditing.OnNext(obj); + /// + public override void ControlTextDidChange(global::Foundation.NSNotification obj) => _controlTextDidChange.OnNext(obj); + /// + public override void ControlTextDidEndEditing(global::Foundation.NSNotification obj) => _controlTextDidEndEditing.OnNext(obj); + /// + public override void DidFailToValidatePartialString(global::AppKit.NSControl control, string str, string error) => _didFailToValidatePartialString.OnNext((control, str, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSDrawerDelegateRx : global::AppKit.NSDrawerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _drawerDidClose = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _drawerDidOpen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _drawerWillClose = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _drawerWillOpen = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DrawerDidCloseObs => _drawerDidClose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DrawerDidOpenObs => _drawerDidOpen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DrawerWillCloseObs => _drawerWillClose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DrawerWillOpenObs => _drawerWillOpen; + /// + public override void DrawerDidClose(global::Foundation.NSNotification notification) => _drawerDidClose.OnNext(notification); + /// + public override void DrawerDidOpen(global::Foundation.NSNotification notification) => _drawerDidOpen.OnNext(notification); + /// + public override void DrawerWillClose(global::Foundation.NSNotification notification) => _drawerWillClose.OnNext(notification); + /// + public override void DrawerWillOpen(global::Foundation.NSNotification notification) => _drawerWillOpen.OnNext(notification); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NSFilePromiseProviderDelegateRx : global::AppKit.NSFilePromiseProviderDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSFilePromiseProvider filePromiseProvider, global::Foundation.NSUrl url, global::System.Action completionHandler)> _writePromiseToUrl = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSFilePromiseProvider filePromiseProvider, global::Foundation.NSUrl url, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSFilePromiseProvider filePromiseProvider, global::Foundation.NSUrl url, global::System.Action completionHandler)> WritePromiseToUrlObs => _writePromiseToUrl; + /// + public override void WritePromiseToUrl(global::AppKit.NSFilePromiseProvider filePromiseProvider, global::Foundation.NSUrl url, global::System.Action completionHandler) => _writePromiseToUrl.OnNext((filePromiseProvider, url, completionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSImageDelegateRx : global::AppKit.NSImageDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSImage image, global::AppKit.NSImageRep rep, global::System.nint rows)> _didLoadPartOfRepresentation = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSImage image, global::AppKit.NSImageRep rep, global::System.nint rows)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSImage image, global::AppKit.NSImageRep rep, global::AppKit.NSImageLoadStatus status)> _didLoadRepresentation = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSImage image, global::AppKit.NSImageRep rep, global::AppKit.NSImageLoadStatus status)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSImage image, global::AppKit.NSImageRep rep)> _didLoadRepresentationHeader = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSImage image, global::AppKit.NSImageRep rep)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSImage image, global::AppKit.NSImageRep rep)> _willLoadRepresentation = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSImage image, global::AppKit.NSImageRep rep)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSImage image, global::AppKit.NSImageRep rep, global::System.nint rows)> DidLoadPartOfRepresentationObs => _didLoadPartOfRepresentation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSImage image, global::AppKit.NSImageRep rep, global::AppKit.NSImageLoadStatus status)> DidLoadRepresentationObs => _didLoadRepresentation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSImage image, global::AppKit.NSImageRep rep)> DidLoadRepresentationHeaderObs => _didLoadRepresentationHeader; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSImage image, global::AppKit.NSImageRep rep)> WillLoadRepresentationObs => _willLoadRepresentation; + /// + public override void DidLoadPartOfRepresentation(global::AppKit.NSImage image, global::AppKit.NSImageRep rep, global::System.nint rows) => _didLoadPartOfRepresentation.OnNext((image, rep, rows)); + /// + public override void DidLoadRepresentation(global::AppKit.NSImage image, global::AppKit.NSImageRep rep, global::AppKit.NSImageLoadStatus status) => _didLoadRepresentation.OnNext((image, rep, status)); + /// + public override void DidLoadRepresentationHeader(global::AppKit.NSImage image, global::AppKit.NSImageRep rep) => _didLoadRepresentationHeader.OnNext((image, rep)); + /// + public override void WillLoadRepresentation(global::AppKit.NSImage image, global::AppKit.NSImageRep rep) => _willLoadRepresentation.OnNext((image, rep)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSLayoutManagerDelegateRx : global::AppKit.NSLayoutManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSLayoutManager layoutManager, global::AppKit.NSTextContainer textContainer, global::CoreGraphics.CGSize oldSize)> _didChangeGeometry = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSLayoutManager layoutManager, global::AppKit.NSTextContainer textContainer, global::CoreGraphics.CGSize oldSize)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSLayoutManager layoutManager, global::AppKit.NSTextContainer textContainer, bool layoutFinishedFlag)> _layoutCompleted = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSLayoutManager layoutManager, global::AppKit.NSTextContainer textContainer, bool layoutFinishedFlag)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _layoutInvalidated = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSLayoutManager layoutManager, global::AppKit.NSTextContainer textContainer, global::CoreGraphics.CGSize oldSize)> DidChangeGeometryObs => _didChangeGeometry; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSLayoutManager layoutManager, global::AppKit.NSTextContainer textContainer, bool layoutFinishedFlag)> LayoutCompletedObs => _layoutCompleted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LayoutInvalidatedObs => _layoutInvalidated; + /// + public override void DidChangeGeometry(global::AppKit.NSLayoutManager layoutManager, global::AppKit.NSTextContainer textContainer, global::CoreGraphics.CGSize oldSize) => _didChangeGeometry.OnNext((layoutManager, textContainer, oldSize)); + /// + public override void LayoutCompleted(global::AppKit.NSLayoutManager layoutManager, global::AppKit.NSTextContainer textContainer, bool layoutFinishedFlag) => _layoutCompleted.OnNext((layoutManager, textContainer, layoutFinishedFlag)); + /// + public override void LayoutInvalidated(global::AppKit.NSLayoutManager sender) => _layoutInvalidated.OnNext(sender); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSMatrixDelegateRx : global::AppKit.NSMatrixDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _controlTextDidBeginEditing = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _controlTextDidChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _controlTextDidEndEditing = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSControl control, string str, string error)> _didFailToValidatePartialString = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSControl control, string str, string error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ControlTextDidBeginEditingObs => _controlTextDidBeginEditing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ControlTextDidChangeObs => _controlTextDidChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ControlTextDidEndEditingObs => _controlTextDidEndEditing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSControl control, string str, string error)> DidFailToValidatePartialStringObs => _didFailToValidatePartialString; + /// + public override void ControlTextDidBeginEditing(global::Foundation.NSNotification obj) => _controlTextDidBeginEditing.OnNext(obj); + /// + public override void ControlTextDidChange(global::Foundation.NSNotification obj) => _controlTextDidChange.OnNext(obj); + /// + public override void ControlTextDidEndEditing(global::Foundation.NSNotification obj) => _controlTextDidEndEditing.OnNext(obj); + /// + public override void DidFailToValidatePartialString(global::AppKit.NSControl control, string str, string error) => _didFailToValidatePartialString.OnNext((control, str, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NSMenuDelegateRx : global::AppKit.NSMenuDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _menuDidClose = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSMenu menu, global::AppKit.NSMenuItem item)> _menuWillHighlightItem = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSMenu menu, global::AppKit.NSMenuItem item)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _menuWillOpen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _needsUpdate = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable MenuDidCloseObs => _menuDidClose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSMenu menu, global::AppKit.NSMenuItem item)> MenuWillHighlightItemObs => _menuWillHighlightItem; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable MenuWillOpenObs => _menuWillOpen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable NeedsUpdateObs => _needsUpdate; + /// + public override void MenuDidClose(global::AppKit.NSMenu menu) => _menuDidClose.OnNext(menu); + /// + public override void MenuWillHighlightItem(global::AppKit.NSMenu menu, global::AppKit.NSMenuItem item) => _menuWillHighlightItem.OnNext((menu, item)); + /// + public override void MenuWillOpen(global::AppKit.NSMenu menu) => _menuWillOpen.OnNext(menu); + /// + public override void NeedsUpdate(global::AppKit.NSMenu menu) => _needsUpdate.OnNext(menu); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSOpenSavePanelDelegateRx : global::AppKit.NSOpenSavePanelDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSavePanel panel, global::Foundation.NSUrl newDirectoryUrl)> _didChangeToDirectory = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSavePanel panel, global::Foundation.NSUrl newDirectoryUrl)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSavePanel panel, string path)> _directoryDidChange = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSavePanel panel, string path)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _selectionDidChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSavePanel panel, bool expanding)> _willExpand = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSavePanel panel, bool expanding)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSavePanel panel, global::Foundation.NSUrl newDirectoryUrl)> DidChangeToDirectoryObs => _didChangeToDirectory; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSavePanel panel, string path)> DirectoryDidChangeObs => _directoryDidChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SelectionDidChangeObs => _selectionDidChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSavePanel panel, bool expanding)> WillExpandObs => _willExpand; + /// + public override void DidChangeToDirectory(global::AppKit.NSSavePanel panel, global::Foundation.NSUrl newDirectoryUrl) => _didChangeToDirectory.OnNext((panel, newDirectoryUrl)); + /// + public override void DirectoryDidChange(global::AppKit.NSSavePanel panel, string path) => _directoryDidChange.OnNext((panel, path)); + /// + public override void SelectionDidChange(global::AppKit.NSSavePanel panel) => _selectionDidChange.OnNext(panel); + /// + public override void WillExpand(global::AppKit.NSSavePanel panel, bool expanding) => _willExpand.OnNext((panel, expanding)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSOutlineViewDelegateRx : global::AppKit.NSOutlineViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _columnDidMove = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _columnDidResize = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableRowView rowView, global::System.nint row)> _didAddRowView = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableRowView rowView, global::System.nint row)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableColumn tableColumn)> _didClickTableColumn = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableColumn tableColumn)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableColumn tableColumn)> _didDragTableColumn = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableColumn tableColumn)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableRowView rowView, global::System.nint row)> _didRemoveRowView = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableRowView rowView, global::System.nint row)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _itemDidCollapse = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _itemDidExpand = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _itemWillCollapse = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _itemWillExpand = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableColumn tableColumn)> _mouseDown = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableColumn tableColumn)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _selectionDidChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _selectionIsChanging = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSOutlineView outlineView, global::Foundation.NSObject cell, global::AppKit.NSTableColumn tableColumn, global::Foundation.NSObject item)> _willDisplayCell = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSOutlineView outlineView, global::Foundation.NSObject cell, global::AppKit.NSTableColumn tableColumn, global::Foundation.NSObject item)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSOutlineView outlineView, global::Foundation.NSObject cell, global::AppKit.NSTableColumn tableColumn, global::Foundation.NSObject item)> _willDisplayOutlineCell = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSOutlineView outlineView, global::Foundation.NSObject cell, global::AppKit.NSTableColumn tableColumn, global::Foundation.NSObject item)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ColumnDidMoveObs => _columnDidMove; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ColumnDidResizeObs => _columnDidResize; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableRowView rowView, global::System.nint row)> DidAddRowViewObs => _didAddRowView; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableColumn tableColumn)> DidClickTableColumnObs => _didClickTableColumn; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableColumn tableColumn)> DidDragTableColumnObs => _didDragTableColumn; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableRowView rowView, global::System.nint row)> DidRemoveRowViewObs => _didRemoveRowView; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ItemDidCollapseObs => _itemDidCollapse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ItemDidExpandObs => _itemDidExpand; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ItemWillCollapseObs => _itemWillCollapse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ItemWillExpandObs => _itemWillExpand; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableColumn tableColumn)> MouseDownObs => _mouseDown; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SelectionDidChangeObs => _selectionDidChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SelectionIsChangingObs => _selectionIsChanging; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSOutlineView outlineView, global::Foundation.NSObject cell, global::AppKit.NSTableColumn tableColumn, global::Foundation.NSObject item)> WillDisplayCellObs => _willDisplayCell; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSOutlineView outlineView, global::Foundation.NSObject cell, global::AppKit.NSTableColumn tableColumn, global::Foundation.NSObject item)> WillDisplayOutlineCellObs => _willDisplayOutlineCell; + /// + public override void ColumnDidMove(global::Foundation.NSNotification notification) => _columnDidMove.OnNext(notification); + /// + public override void ColumnDidResize(global::Foundation.NSNotification notification) => _columnDidResize.OnNext(notification); + /// + public override void DidAddRowView(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableRowView rowView, global::System.nint row) => _didAddRowView.OnNext((outlineView, rowView, row)); + /// + public override void DidClickTableColumn(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableColumn tableColumn) => _didClickTableColumn.OnNext((outlineView, tableColumn)); + /// + public override void DidDragTableColumn(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableColumn tableColumn) => _didDragTableColumn.OnNext((outlineView, tableColumn)); + /// + public override void DidRemoveRowView(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableRowView rowView, global::System.nint row) => _didRemoveRowView.OnNext((outlineView, rowView, row)); + /// + public override void ItemDidCollapse(global::Foundation.NSNotification notification) => _itemDidCollapse.OnNext(notification); + /// + public override void ItemDidExpand(global::Foundation.NSNotification notification) => _itemDidExpand.OnNext(notification); + /// + public override void ItemWillCollapse(global::Foundation.NSNotification notification) => _itemWillCollapse.OnNext(notification); + /// + public override void ItemWillExpand(global::Foundation.NSNotification notification) => _itemWillExpand.OnNext(notification); + /// + public override void MouseDown(global::AppKit.NSOutlineView outlineView, global::AppKit.NSTableColumn tableColumn) => _mouseDown.OnNext((outlineView, tableColumn)); + /// + public override void SelectionDidChange(global::Foundation.NSNotification notification) => _selectionDidChange.OnNext(notification); + /// + public override void SelectionIsChanging(global::Foundation.NSNotification notification) => _selectionIsChanging.OnNext(notification); + /// + public override void WillDisplayCell(global::AppKit.NSOutlineView outlineView, global::Foundation.NSObject cell, global::AppKit.NSTableColumn tableColumn, global::Foundation.NSObject item) => _willDisplayCell.OnNext((outlineView, cell, tableColumn, item)); + /// + public override void WillDisplayOutlineCell(global::AppKit.NSOutlineView outlineView, global::Foundation.NSObject cell, global::AppKit.NSTableColumn tableColumn, global::Foundation.NSObject item) => _willDisplayOutlineCell.OnNext((outlineView, cell, tableColumn, item)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSPageControllerDelegateRx : global::AppKit.NSPageControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didEndLiveTransition = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSPageController pageController, global::Foundation.NSObject targetObject)> _didTransition = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSPageController pageController, global::Foundation.NSObject targetObject)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSPageController pageController, global::AppKit.NSViewController viewController, global::Foundation.NSObject targetObject)> _prepareViewController = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSPageController pageController, global::AppKit.NSViewController viewController, global::Foundation.NSObject targetObject)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStartLiveTransition = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndLiveTransitionObs => _didEndLiveTransition; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSPageController pageController, global::Foundation.NSObject targetObject)> DidTransitionObs => _didTransition; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSPageController pageController, global::AppKit.NSViewController viewController, global::Foundation.NSObject targetObject)> PrepareViewControllerObs => _prepareViewController; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStartLiveTransitionObs => _willStartLiveTransition; + /// + public override void DidEndLiveTransition(global::AppKit.NSPageController pageController) => _didEndLiveTransition.OnNext(pageController); + /// + public override void DidTransition(global::AppKit.NSPageController pageController, global::Foundation.NSObject targetObject) => _didTransition.OnNext((pageController, targetObject)); + /// + public override void PrepareViewController(global::AppKit.NSPageController pageController, global::AppKit.NSViewController viewController, global::Foundation.NSObject targetObject) => _prepareViewController.OnNext((pageController, viewController, targetObject)); + /// + public override void WillStartLiveTransition(global::AppKit.NSPageController pageController) => _willStartLiveTransition.OnNext(pageController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSPathCellDelegateRx : global::AppKit.NSPathCellDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSPathCell pathCell, global::AppKit.NSOpenPanel openPanel)> _willDisplayOpenPanel = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSPathCell pathCell, global::AppKit.NSOpenPanel openPanel)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSPathCell pathCell, global::AppKit.NSMenu menu)> _willPopupMenu = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSPathCell pathCell, global::AppKit.NSMenu menu)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSPathCell pathCell, global::AppKit.NSOpenPanel openPanel)> WillDisplayOpenPanelObs => _willDisplayOpenPanel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSPathCell pathCell, global::AppKit.NSMenu menu)> WillPopupMenuObs => _willPopupMenu; + /// + public override void WillDisplayOpenPanel(global::AppKit.NSPathCell pathCell, global::AppKit.NSOpenPanel openPanel) => _willDisplayOpenPanel.OnNext((pathCell, openPanel)); + /// + public override void WillPopupMenu(global::AppKit.NSPathCell pathCell, global::AppKit.NSMenu menu) => _willPopupMenu.OnNext((pathCell, menu)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSPathControlDelegateRx : global::AppKit.NSPathControlDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSPathControl pathControl, global::AppKit.NSOpenPanel openPanel)> _willDisplayOpenPanel = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSPathControl pathControl, global::AppKit.NSOpenPanel openPanel)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSPathControl pathControl, global::AppKit.NSMenu menu)> _willPopUpMenu = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSPathControl pathControl, global::AppKit.NSMenu menu)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSPathControl pathControl, global::AppKit.NSOpenPanel openPanel)> WillDisplayOpenPanelObs => _willDisplayOpenPanel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSPathControl pathControl, global::AppKit.NSMenu menu)> WillPopUpMenuObs => _willPopUpMenu; + /// + public override void WillDisplayOpenPanel(global::AppKit.NSPathControl pathControl, global::AppKit.NSOpenPanel openPanel) => _willDisplayOpenPanel.OnNext((pathControl, openPanel)); + /// + public override void WillPopUpMenu(global::AppKit.NSPathControl pathControl, global::AppKit.NSMenu menu) => _willPopUpMenu.OnNext((pathControl, menu)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSPopoverDelegateRx : global::AppKit.NSPopoverDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didClose = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didDetach = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didShow = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willClose = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willShow = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidCloseObs => _didClose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDetachObs => _didDetach; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidShowObs => _didShow; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillCloseObs => _willClose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillShowObs => _willShow; + /// + public override void DidClose(global::Foundation.NSNotification notification) => _didClose.OnNext(notification); + /// + public override void DidDetach(global::AppKit.NSPopover popover) => _didDetach.OnNext(popover); + /// + public override void DidShow(global::Foundation.NSNotification notification) => _didShow.OnNext(notification); + /// + public override void WillClose(global::Foundation.NSNotification notification) => _willClose.OnNext(notification); + /// + public override void WillShow(global::Foundation.NSNotification notification) => _willShow.OnNext(notification); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NSRuleEditorDelegateRx : global::AppKit.NSRuleEditorDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _changed = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _editingBegan = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _editingEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _rowsDidChange = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ChangedObs => _changed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable EditingBeganObs => _editingBegan; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable EditingEndedObs => _editingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable RowsDidChangeObs => _rowsDidChange; + /// + public override void Changed(global::Foundation.NSNotification notification) => _changed.OnNext(notification); + /// + public override void EditingBegan(global::Foundation.NSNotification notification) => _editingBegan.OnNext(notification); + /// + public override void EditingEnded(global::Foundation.NSNotification notification) => _editingEnded.OnNext(notification); + /// + public override void RowsDidChange(global::Foundation.NSNotification notification) => _rowsDidChange.OnNext(notification); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSScrubberDelegateRx : global::AppKit.NSScrubberDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBeginInteracting = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didCancelInteracting = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSScrubber scrubber, global::Foundation.NSRange visibleRange)> _didChangeVisible = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSScrubber scrubber, global::Foundation.NSRange visibleRange)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinishInteracting = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSScrubber scrubber, global::System.nint highlightedIndex)> _didHighlightItem = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSScrubber scrubber, global::System.nint highlightedIndex)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSScrubber scrubber, global::System.nint selectedIndex)> _didSelectItem = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSScrubber scrubber, global::System.nint selectedIndex)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBeginInteractingObs => _didBeginInteracting; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidCancelInteractingObs => _didCancelInteracting; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSScrubber scrubber, global::Foundation.NSRange visibleRange)> DidChangeVisibleObs => _didChangeVisible; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishInteractingObs => _didFinishInteracting; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSScrubber scrubber, global::System.nint highlightedIndex)> DidHighlightItemObs => _didHighlightItem; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSScrubber scrubber, global::System.nint selectedIndex)> DidSelectItemObs => _didSelectItem; + /// + public override void DidBeginInteracting(global::AppKit.NSScrubber scrubber) => _didBeginInteracting.OnNext(scrubber); + /// + public override void DidCancelInteracting(global::AppKit.NSScrubber scrubber) => _didCancelInteracting.OnNext(scrubber); + /// + public override void DidChangeVisible(global::AppKit.NSScrubber scrubber, global::Foundation.NSRange visibleRange) => _didChangeVisible.OnNext((scrubber, visibleRange)); + /// + public override void DidFinishInteracting(global::AppKit.NSScrubber scrubber) => _didFinishInteracting.OnNext(scrubber); + /// + public override void DidHighlightItem(global::AppKit.NSScrubber scrubber, global::System.nint highlightedIndex) => _didHighlightItem.OnNext((scrubber, highlightedIndex)); + /// + public override void DidSelectItem(global::AppKit.NSScrubber scrubber, global::System.nint selectedIndex) => _didSelectItem.OnNext((scrubber, selectedIndex)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSScrubberFlowLayoutDelegateRx : global::AppKit.NSScrubberFlowLayoutDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBeginInteracting = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didCancelInteracting = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSScrubber scrubber, global::Foundation.NSRange visibleRange)> _didChangeVisible = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSScrubber scrubber, global::Foundation.NSRange visibleRange)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinishInteracting = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSScrubber scrubber, global::System.nint highlightedIndex)> _didHighlightItem = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSScrubber scrubber, global::System.nint highlightedIndex)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSScrubber scrubber, global::System.nint selectedIndex)> _didSelectItem = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSScrubber scrubber, global::System.nint selectedIndex)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBeginInteractingObs => _didBeginInteracting; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidCancelInteractingObs => _didCancelInteracting; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSScrubber scrubber, global::Foundation.NSRange visibleRange)> DidChangeVisibleObs => _didChangeVisible; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishInteractingObs => _didFinishInteracting; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSScrubber scrubber, global::System.nint highlightedIndex)> DidHighlightItemObs => _didHighlightItem; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSScrubber scrubber, global::System.nint selectedIndex)> DidSelectItemObs => _didSelectItem; + /// + public override void DidBeginInteracting(global::AppKit.NSScrubber scrubber) => _didBeginInteracting.OnNext(scrubber); + /// + public override void DidCancelInteracting(global::AppKit.NSScrubber scrubber) => _didCancelInteracting.OnNext(scrubber); + /// + public override void DidChangeVisible(global::AppKit.NSScrubber scrubber, global::Foundation.NSRange visibleRange) => _didChangeVisible.OnNext((scrubber, visibleRange)); + /// + public override void DidFinishInteracting(global::AppKit.NSScrubber scrubber) => _didFinishInteracting.OnNext(scrubber); + /// + public override void DidHighlightItem(global::AppKit.NSScrubber scrubber, global::System.nint highlightedIndex) => _didHighlightItem.OnNext((scrubber, highlightedIndex)); + /// + public override void DidSelectItem(global::AppKit.NSScrubber scrubber, global::System.nint selectedIndex) => _didSelectItem.OnNext((scrubber, selectedIndex)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSSearchFieldDelegateRx : global::AppKit.NSSearchFieldDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _changed = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSControl control, string str, string error)> _didFailToValidatePartialString = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSControl control, string str, string error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _editingBegan = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _editingEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _searchingEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _searchingStarted = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ChangedObs => _changed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSControl control, string str, string error)> DidFailToValidatePartialStringObs => _didFailToValidatePartialString; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable EditingBeganObs => _editingBegan; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable EditingEndedObs => _editingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SearchingEndedObs => _searchingEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SearchingStartedObs => _searchingStarted; + /// + public override void Changed(global::Foundation.NSNotification notification) => _changed.OnNext(notification); + /// + public override void DidFailToValidatePartialString(global::AppKit.NSControl control, string str, string error) => _didFailToValidatePartialString.OnNext((control, str, error)); + /// + public override void EditingBegan(global::Foundation.NSNotification notification) => _editingBegan.OnNext(notification); + /// + public override void EditingEnded(global::Foundation.NSNotification notification) => _editingEnded.OnNext(notification); + /// + public override void SearchingEnded(global::AppKit.NSSearchField sender) => _searchingEnded.OnNext(sender); + /// + public override void SearchingStarted(global::AppKit.NSSearchField sender) => _searchingStarted.OnNext(sender); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSSharingServiceDelegateRx : global::AppKit.NSSharingServiceDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items, global::Foundation.NSError error)> _didFailToShareItems = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items)> _didShareItems = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items)> _willShareItems = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items, global::Foundation.NSError error)> DidFailToShareItemsObs => _didFailToShareItems; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items)> DidShareItemsObs => _didShareItems; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items)> WillShareItemsObs => _willShareItems; + /// + public override void DidFailToShareItems(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items, global::Foundation.NSError error) => _didFailToShareItems.OnNext((sharingService, items, error)); + /// + public override void DidShareItems(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items) => _didShareItems.OnNext((sharingService, items)); + /// + public override void WillShareItems(global::AppKit.NSSharingService sharingService, global::Foundation.NSObject[] items) => _willShareItems.OnNext((sharingService, items)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSSharingServicePickerDelegateRx : global::AppKit.NSSharingServicePickerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingServicePicker sharingServicePicker, global::AppKit.NSSharingService service)> _didChooseSharingService = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingServicePicker sharingServicePicker, global::AppKit.NSSharingService service)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSharingServicePicker sharingServicePicker, global::AppKit.NSSharingService service)> DidChooseSharingServiceObs => _didChooseSharingService; + /// + public override void DidChooseSharingService(global::AppKit.NSSharingServicePicker sharingServicePicker, global::AppKit.NSSharingService service) => _didChooseSharingService.OnNext((sharingServicePicker, service)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NSSharingServicePickerTouchBarItemDelegateRx : global::AppKit.NSSharingServicePickerTouchBarItemDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingServicePicker sharingServicePicker, global::AppKit.NSSharingService service)> _didChooseSharingService = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSharingServicePicker sharingServicePicker, global::AppKit.NSSharingService service)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSharingServicePicker sharingServicePicker, global::AppKit.NSSharingService service)> DidChooseSharingServiceObs => _didChooseSharingService; + /// + public override void DidChooseSharingService(global::AppKit.NSSharingServicePicker sharingServicePicker, global::AppKit.NSSharingService service) => _didChooseSharingService.OnNext((sharingServicePicker, service)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSSoundDelegateRx : global::AppKit.NSSoundDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSound sound, bool finished)> _didFinishPlaying = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSound sound, bool finished)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSound sound, bool finished)> DidFinishPlayingObs => _didFinishPlaying; + /// + public override void DidFinishPlaying(global::AppKit.NSSound sound, bool finished) => _didFinishPlaying.OnNext((sound, finished)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSSpeechRecognizerDelegateRx : global::AppKit.NSSpeechRecognizerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSpeechRecognizer sender, string command)> _didRecognizeCommand = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSpeechRecognizer sender, string command)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSpeechRecognizer sender, string command)> DidRecognizeCommandObs => _didRecognizeCommand; + /// + public override void DidRecognizeCommand(global::AppKit.NSSpeechRecognizer sender, string command) => _didRecognizeCommand.OnNext((sender, command)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSSpeechSynthesizerDelegateRx : global::AppKit.NSSpeechSynthesizerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSpeechSynthesizer sender, global::System.nuint characterIndex, string theString, string message)> _didEncounterError = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSpeechSynthesizer sender, global::System.nuint characterIndex, string theString, string message)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSpeechSynthesizer sender, string message)> _didEncounterSyncMessage = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSpeechSynthesizer sender, string message)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSpeechSynthesizer sender, bool finishedSpeaking)> _didFinishSpeaking = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSpeechSynthesizer sender, bool finishedSpeaking)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSpeechSynthesizer sender, short phonemeOpcode)> _willSpeakPhoneme = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSpeechSynthesizer sender, short phonemeOpcode)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSpeechSynthesizer sender, global::Foundation.NSRange wordCharacterRange, string ofString)> _willSpeakWord = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSpeechSynthesizer sender, global::Foundation.NSRange wordCharacterRange, string ofString)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSpeechSynthesizer sender, global::System.nuint characterIndex, string theString, string message)> DidEncounterErrorObs => _didEncounterError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSpeechSynthesizer sender, string message)> DidEncounterSyncMessageObs => _didEncounterSyncMessage; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSpeechSynthesizer sender, bool finishedSpeaking)> DidFinishSpeakingObs => _didFinishSpeaking; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSpeechSynthesizer sender, short phonemeOpcode)> WillSpeakPhonemeObs => _willSpeakPhoneme; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSpeechSynthesizer sender, global::Foundation.NSRange wordCharacterRange, string ofString)> WillSpeakWordObs => _willSpeakWord; + /// + public override void DidEncounterError(global::AppKit.NSSpeechSynthesizer sender, global::System.nuint characterIndex, string theString, string message) => _didEncounterError.OnNext((sender, characterIndex, theString, message)); + /// + public override void DidEncounterSyncMessage(global::AppKit.NSSpeechSynthesizer sender, string message) => _didEncounterSyncMessage.OnNext((sender, message)); + /// + public override void DidFinishSpeaking(global::AppKit.NSSpeechSynthesizer sender, bool finishedSpeaking) => _didFinishSpeaking.OnNext((sender, finishedSpeaking)); + /// + public override void WillSpeakPhoneme(global::AppKit.NSSpeechSynthesizer sender, short phonemeOpcode) => _willSpeakPhoneme.OnNext((sender, phonemeOpcode)); + /// + public override void WillSpeakWord(global::AppKit.NSSpeechSynthesizer sender, global::Foundation.NSRange wordCharacterRange, string ofString) => _willSpeakWord.OnNext((sender, wordCharacterRange, ofString)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSSplitViewDelegateRx : global::AppKit.NSSplitViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didResizeSubviews = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSplitView splitView, global::CoreGraphics.CGSize oldSize)> _resize = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSSplitView splitView, global::CoreGraphics.CGSize oldSize)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _splitViewWillResizeSubviews = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidResizeSubviewsObs => _didResizeSubviews; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSSplitView splitView, global::CoreGraphics.CGSize oldSize)> ResizeObs => _resize; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SplitViewWillResizeSubviewsObs => _splitViewWillResizeSubviews; + /// + public override void DidResizeSubviews(global::Foundation.NSNotification notification) => _didResizeSubviews.OnNext(notification); + /// + public override void Resize(global::AppKit.NSSplitView splitView, global::CoreGraphics.CGSize oldSize) => _resize.OnNext((splitView, oldSize)); + /// + public override void SplitViewWillResizeSubviews(global::Foundation.NSNotification notification) => _splitViewWillResizeSubviews.OnNext(notification); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSStackViewDelegateRx : global::AppKit.NSStackViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSStackView stackView, global::AppKit.NSView[] views)> _didReattachViews = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSStackView stackView, global::AppKit.NSView[] views)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSStackView stackView, global::AppKit.NSView[] views)> _willDetachViews = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSStackView stackView, global::AppKit.NSView[] views)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSStackView stackView, global::AppKit.NSView[] views)> DidReattachViewsObs => _didReattachViews; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSStackView stackView, global::AppKit.NSView[] views)> WillDetachViewsObs => _willDetachViews; + /// + public override void DidReattachViews(global::AppKit.NSStackView stackView, global::AppKit.NSView[] views) => _didReattachViews.OnNext((stackView, views)); + /// + public override void WillDetachViews(global::AppKit.NSStackView stackView, global::AppKit.NSView[] views) => _willDetachViews.OnNext((stackView, views)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSTableViewDelegateRx : global::AppKit.NSTableViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _columnDidMove = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _columnDidResize = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTableView tableView, global::AppKit.NSTableRowView rowView, global::System.nint row)> _didAddRowView = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTableView tableView, global::AppKit.NSTableRowView rowView, global::System.nint row)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTableView tableView, global::AppKit.NSTableColumn tableColumn)> _didClickTableColumn = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTableView tableView, global::AppKit.NSTableColumn tableColumn)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTableView tableView, global::AppKit.NSTableColumn tableColumn)> _didDragTableColumn = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTableView tableView, global::AppKit.NSTableColumn tableColumn)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTableView tableView, global::AppKit.NSTableRowView rowView, global::System.nint row)> _didRemoveRowView = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTableView tableView, global::AppKit.NSTableRowView rowView, global::System.nint row)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTableView tableView, global::AppKit.NSTableColumn tableColumn)> _mouseDownInHeaderOfTableColumn = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTableView tableView, global::AppKit.NSTableColumn tableColumn)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _selectionDidChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _selectionIsChanging = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTableView tableView, global::Foundation.NSObject cell, global::AppKit.NSTableColumn tableColumn, global::System.nint row)> _willDisplayCell = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTableView tableView, global::Foundation.NSObject cell, global::AppKit.NSTableColumn tableColumn, global::System.nint row)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ColumnDidMoveObs => _columnDidMove; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ColumnDidResizeObs => _columnDidResize; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSTableView tableView, global::AppKit.NSTableRowView rowView, global::System.nint row)> DidAddRowViewObs => _didAddRowView; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSTableView tableView, global::AppKit.NSTableColumn tableColumn)> DidClickTableColumnObs => _didClickTableColumn; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSTableView tableView, global::AppKit.NSTableColumn tableColumn)> DidDragTableColumnObs => _didDragTableColumn; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSTableView tableView, global::AppKit.NSTableRowView rowView, global::System.nint row)> DidRemoveRowViewObs => _didRemoveRowView; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSTableView tableView, global::AppKit.NSTableColumn tableColumn)> MouseDownInHeaderOfTableColumnObs => _mouseDownInHeaderOfTableColumn; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SelectionDidChangeObs => _selectionDidChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SelectionIsChangingObs => _selectionIsChanging; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSTableView tableView, global::Foundation.NSObject cell, global::AppKit.NSTableColumn tableColumn, global::System.nint row)> WillDisplayCellObs => _willDisplayCell; + /// + public override void ColumnDidMove(global::Foundation.NSNotification notification) => _columnDidMove.OnNext(notification); + /// + public override void ColumnDidResize(global::Foundation.NSNotification notification) => _columnDidResize.OnNext(notification); + /// + public override void DidAddRowView(global::AppKit.NSTableView tableView, global::AppKit.NSTableRowView rowView, global::System.nint row) => _didAddRowView.OnNext((tableView, rowView, row)); + /// + public override void DidClickTableColumn(global::AppKit.NSTableView tableView, global::AppKit.NSTableColumn tableColumn) => _didClickTableColumn.OnNext((tableView, tableColumn)); + /// + public override void DidDragTableColumn(global::AppKit.NSTableView tableView, global::AppKit.NSTableColumn tableColumn) => _didDragTableColumn.OnNext((tableView, tableColumn)); + /// + public override void DidRemoveRowView(global::AppKit.NSTableView tableView, global::AppKit.NSTableRowView rowView, global::System.nint row) => _didRemoveRowView.OnNext((tableView, rowView, row)); + /// + public override void MouseDownInHeaderOfTableColumn(global::AppKit.NSTableView tableView, global::AppKit.NSTableColumn tableColumn) => _mouseDownInHeaderOfTableColumn.OnNext((tableView, tableColumn)); + /// + public override void SelectionDidChange(global::Foundation.NSNotification notification) => _selectionDidChange.OnNext(notification); + /// + public override void SelectionIsChanging(global::Foundation.NSNotification notification) => _selectionIsChanging.OnNext(notification); + /// + public override void WillDisplayCell(global::AppKit.NSTableView tableView, global::Foundation.NSObject cell, global::AppKit.NSTableColumn tableColumn, global::System.nint row) => _willDisplayCell.OnNext((tableView, cell, tableColumn, row)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSTabViewDelegateRx : global::AppKit.NSTabViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTabView tabView, global::AppKit.NSTabViewItem item)> _didSelect = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTabView tabView, global::AppKit.NSTabViewItem item)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _numberOfItemsChanged = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTabView tabView, global::AppKit.NSTabViewItem item)> _willSelect = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTabView tabView, global::AppKit.NSTabViewItem item)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSTabView tabView, global::AppKit.NSTabViewItem item)> DidSelectObs => _didSelect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable NumberOfItemsChangedObs => _numberOfItemsChanged; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSTabView tabView, global::AppKit.NSTabViewItem item)> WillSelectObs => _willSelect; + /// + public override void DidSelect(global::AppKit.NSTabView tabView, global::AppKit.NSTabViewItem item) => _didSelect.OnNext((tabView, item)); + /// + public override void NumberOfItemsChanged(global::AppKit.NSTabView tabView) => _numberOfItemsChanged.OnNext(tabView); + /// + public override void WillSelect(global::AppKit.NSTabView tabView, global::AppKit.NSTabViewItem item) => _willSelect.OnNext((tabView, item)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSTextDelegateRx : global::AppKit.NSTextDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _textDidBeginEditing = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _textDidChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _textDidEndEditing = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable TextDidBeginEditingObs => _textDidBeginEditing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable TextDidChangeObs => _textDidChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable TextDidEndEditingObs => _textDidEndEditing; + /// + public override void TextDidBeginEditing(global::Foundation.NSNotification notification) => _textDidBeginEditing.OnNext(notification); + /// + public override void TextDidChange(global::Foundation.NSNotification notification) => _textDidChange.OnNext(notification); + /// + public override void TextDidEndEditing(global::Foundation.NSNotification notification) => _textDidEndEditing.OnNext(notification); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSTextFieldDelegateRx : global::AppKit.NSTextFieldDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _changed = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSControl control, string str, string error)> _didFailToValidatePartialString = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSControl control, string str, string error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _editingBegan = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _editingEnded = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ChangedObs => _changed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSControl control, string str, string error)> DidFailToValidatePartialStringObs => _didFailToValidatePartialString; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable EditingBeganObs => _editingBegan; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable EditingEndedObs => _editingEnded; + /// + public override void Changed(global::Foundation.NSNotification notification) => _changed.OnNext(notification); + /// + public override void DidFailToValidatePartialString(global::AppKit.NSControl control, string str, string error) => _didFailToValidatePartialString.OnNext((control, str, error)); + /// + public override void EditingBegan(global::Foundation.NSNotification notification) => _editingBegan.OnNext(notification); + /// + public override void EditingEnded(global::Foundation.NSNotification notification) => _editingEnded.OnNext(notification); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSTextStorageDelegateRx : global::AppKit.NSTextStorageDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTextStorage textStorage, global::AppKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta)> _didProcessEditing = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTextStorage textStorage, global::AppKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _textStorageDidProcessEditing = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _textStorageWillProcessEditing = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTextStorage textStorage, global::AppKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta)> _willProcessEditing = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTextStorage textStorage, global::AppKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSTextStorage textStorage, global::AppKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta)> DidProcessEditingObs => _didProcessEditing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable TextStorageDidProcessEditingObs => _textStorageDidProcessEditing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable TextStorageWillProcessEditingObs => _textStorageWillProcessEditing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSTextStorage textStorage, global::AppKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta)> WillProcessEditingObs => _willProcessEditing; + /// + public override void DidProcessEditing(global::AppKit.NSTextStorage textStorage, global::AppKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta) => _didProcessEditing.OnNext((textStorage, editedMask, editedRange, delta)); + /// + public override void TextStorageDidProcessEditing(global::Foundation.NSNotification notification) => _textStorageDidProcessEditing.OnNext(notification); + /// + public override void TextStorageWillProcessEditing(global::Foundation.NSNotification notification) => _textStorageWillProcessEditing.OnNext(notification); + /// + public override void WillProcessEditing(global::AppKit.NSTextStorage textStorage, global::AppKit.NSTextStorageEditActions editedMask, global::Foundation.NSRange editedRange, global::System.nint delta) => _willProcessEditing.OnNext((textStorage, editedMask, editedRange, delta)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSTextViewDelegateRx : global::AppKit.NSTextViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTextView textView, global::AppKit.NSTextAttachmentCell cell, global::CoreGraphics.CGRect cellFrame, global::System.nuint charIndex)> _cellClicked = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTextView textView, global::AppKit.NSTextAttachmentCell cell, global::CoreGraphics.CGRect cellFrame, global::System.nuint charIndex)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTextView textView, global::AppKit.NSTextAttachmentCell cell, global::CoreGraphics.CGRect cellFrame, global::System.nuint charIndex)> _cellDoubleClicked = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTextView textView, global::AppKit.NSTextAttachmentCell cell, global::CoreGraphics.CGRect cellFrame, global::System.nuint charIndex)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeSelection = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeTypingAttributes = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTextView view, global::AppKit.NSTextAttachmentCell cell, global::CoreGraphics.CGRect rect, global::AppKit.NSEvent theevent)> _draggedCell = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSTextView view, global::AppKit.NSTextAttachmentCell cell, global::CoreGraphics.CGRect rect, global::AppKit.NSEvent theevent)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSTextView textView, global::AppKit.NSTextAttachmentCell cell, global::CoreGraphics.CGRect cellFrame, global::System.nuint charIndex)> CellClickedObs => _cellClicked; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSTextView textView, global::AppKit.NSTextAttachmentCell cell, global::CoreGraphics.CGRect cellFrame, global::System.nuint charIndex)> CellDoubleClickedObs => _cellDoubleClicked; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeSelectionObs => _didChangeSelection; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeTypingAttributesObs => _didChangeTypingAttributes; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSTextView view, global::AppKit.NSTextAttachmentCell cell, global::CoreGraphics.CGRect rect, global::AppKit.NSEvent theevent)> DraggedCellObs => _draggedCell; + /// + public override void CellClicked(global::AppKit.NSTextView textView, global::AppKit.NSTextAttachmentCell cell, global::CoreGraphics.CGRect cellFrame, global::System.nuint charIndex) => _cellClicked.OnNext((textView, cell, cellFrame, charIndex)); + /// + public override void CellDoubleClicked(global::AppKit.NSTextView textView, global::AppKit.NSTextAttachmentCell cell, global::CoreGraphics.CGRect cellFrame, global::System.nuint charIndex) => _cellDoubleClicked.OnNext((textView, cell, cellFrame, charIndex)); + /// + public override void DidChangeSelection(global::Foundation.NSNotification notification) => _didChangeSelection.OnNext(notification); + /// + public override void DidChangeTypingAttributes(global::Foundation.NSNotification notification) => _didChangeTypingAttributes.OnNext(notification); + /// + public override void DraggedCell(global::AppKit.NSTextView view, global::AppKit.NSTextAttachmentCell cell, global::CoreGraphics.CGRect rect, global::AppKit.NSEvent theevent) => _draggedCell.OnNext((view, cell, rect, theevent)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSToolbarDelegateRx : global::AppKit.NSToolbarDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didRemoveItem = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willAddItem = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidRemoveItemObs => _didRemoveItem; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillAddItemObs => _willAddItem; + /// + public override void DidRemoveItem(global::Foundation.NSNotification notification) => _didRemoveItem.OnNext(notification); + /// + public override void WillAddItem(global::Foundation.NSNotification notification) => _willAddItem.OnNext(notification); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSWindowDelegateRx : global::AppKit.NSWindowDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeKey = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeMain = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeBackingProperties = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeScreen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeScreenProfile = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, global::Foundation.NSCoder coder)> _didDecodeRestorableState = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, global::Foundation.NSCoder coder)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didDeminiaturize = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEndLiveResize = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEndSheet = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEnterFullScreen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEnterVersionBrowser = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didExitFullScreen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didExitVersionBrowser = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didExpose = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFailToEnterFullScreen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFailToExitFullScreen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didMiniaturize = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didMove = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didResignKey = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didResignMain = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didResize = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdate = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, double duration)> _startCustomAnimationToEnterFullScreen = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, double duration)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, double duration)> _startCustomAnimationToExitFullScreen = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, double duration)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willBeginSheet = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willClose = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, global::Foundation.NSCoder coder)> _willEncodeRestorableState = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, global::Foundation.NSCoder coder)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willEnterFullScreen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willEnterVersionBrowser = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willExitFullScreen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willExitVersionBrowser = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willMiniaturize = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willMove = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStartLiveResize = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeKeyObs => _didBecomeKey; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeMainObs => _didBecomeMain; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeBackingPropertiesObs => _didChangeBackingProperties; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeScreenObs => _didChangeScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeScreenProfileObs => _didChangeScreenProfile; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSWindow window, global::Foundation.NSCoder coder)> DidDecodeRestorableStateObs => _didDecodeRestorableState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDeminiaturizeObs => _didDeminiaturize; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndLiveResizeObs => _didEndLiveResize; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndSheetObs => _didEndSheet; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEnterFullScreenObs => _didEnterFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEnterVersionBrowserObs => _didEnterVersionBrowser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidExitFullScreenObs => _didExitFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidExitVersionBrowserObs => _didExitVersionBrowser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidExposeObs => _didExpose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFailToEnterFullScreenObs => _didFailToEnterFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFailToExitFullScreenObs => _didFailToExitFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidMiniaturizeObs => _didMiniaturize; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidMoveObs => _didMove; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidResignKeyObs => _didResignKey; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidResignMainObs => _didResignMain; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidResizeObs => _didResize; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateObs => _didUpdate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSWindow window, double duration)> StartCustomAnimationToEnterFullScreenObs => _startCustomAnimationToEnterFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSWindow window, double duration)> StartCustomAnimationToExitFullScreenObs => _startCustomAnimationToExitFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillBeginSheetObs => _willBeginSheet; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillCloseObs => _willClose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSWindow window, global::Foundation.NSCoder coder)> WillEncodeRestorableStateObs => _willEncodeRestorableState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillEnterFullScreenObs => _willEnterFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillEnterVersionBrowserObs => _willEnterVersionBrowser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillExitFullScreenObs => _willExitFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillExitVersionBrowserObs => _willExitVersionBrowser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillMiniaturizeObs => _willMiniaturize; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillMoveObs => _willMove; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStartLiveResizeObs => _willStartLiveResize; + /// + public override void DidBecomeKey(global::Foundation.NSNotification notification) => _didBecomeKey.OnNext(notification); + /// + public override void DidBecomeMain(global::Foundation.NSNotification notification) => _didBecomeMain.OnNext(notification); + /// + public override void DidChangeBackingProperties(global::Foundation.NSNotification notification) => _didChangeBackingProperties.OnNext(notification); + /// + public override void DidChangeScreen(global::Foundation.NSNotification notification) => _didChangeScreen.OnNext(notification); + /// + public override void DidChangeScreenProfile(global::Foundation.NSNotification notification) => _didChangeScreenProfile.OnNext(notification); + /// + public override void DidDecodeRestorableState(global::AppKit.NSWindow window, global::Foundation.NSCoder coder) => _didDecodeRestorableState.OnNext((window, coder)); + /// + public override void DidDeminiaturize(global::Foundation.NSNotification notification) => _didDeminiaturize.OnNext(notification); + /// + public override void DidEndLiveResize(global::Foundation.NSNotification notification) => _didEndLiveResize.OnNext(notification); + /// + public override void DidEndSheet(global::Foundation.NSNotification notification) => _didEndSheet.OnNext(notification); + /// + public override void DidEnterFullScreen(global::Foundation.NSNotification notification) => _didEnterFullScreen.OnNext(notification); + /// + public override void DidEnterVersionBrowser(global::Foundation.NSNotification notification) => _didEnterVersionBrowser.OnNext(notification); + /// + public override void DidExitFullScreen(global::Foundation.NSNotification notification) => _didExitFullScreen.OnNext(notification); + /// + public override void DidExitVersionBrowser(global::Foundation.NSNotification notification) => _didExitVersionBrowser.OnNext(notification); + /// + public override void DidExpose(global::Foundation.NSNotification notification) => _didExpose.OnNext(notification); + /// + public override void DidFailToEnterFullScreen(global::AppKit.NSWindow window) => _didFailToEnterFullScreen.OnNext(window); + /// + public override void DidFailToExitFullScreen(global::AppKit.NSWindow window) => _didFailToExitFullScreen.OnNext(window); + /// + public override void DidMiniaturize(global::Foundation.NSNotification notification) => _didMiniaturize.OnNext(notification); + /// + public override void DidMove(global::Foundation.NSNotification notification) => _didMove.OnNext(notification); + /// + public override void DidResignKey(global::Foundation.NSNotification notification) => _didResignKey.OnNext(notification); + /// + public override void DidResignMain(global::Foundation.NSNotification notification) => _didResignMain.OnNext(notification); + /// + public override void DidResize(global::Foundation.NSNotification notification) => _didResize.OnNext(notification); + /// + public override void DidUpdate(global::Foundation.NSNotification notification) => _didUpdate.OnNext(notification); + /// + public override void StartCustomAnimationToEnterFullScreen(global::AppKit.NSWindow window, double duration) => _startCustomAnimationToEnterFullScreen.OnNext((window, duration)); + /// + public override void StartCustomAnimationToExitFullScreen(global::AppKit.NSWindow window, double duration) => _startCustomAnimationToExitFullScreen.OnNext((window, duration)); + /// + public override void WillBeginSheet(global::Foundation.NSNotification notification) => _willBeginSheet.OnNext(notification); + /// + public override void WillClose(global::Foundation.NSNotification notification) => _willClose.OnNext(notification); + /// + public override void WillEncodeRestorableState(global::AppKit.NSWindow window, global::Foundation.NSCoder coder) => _willEncodeRestorableState.OnNext((window, coder)); + /// + public override void WillEnterFullScreen(global::Foundation.NSNotification notification) => _willEnterFullScreen.OnNext(notification); + /// + public override void WillEnterVersionBrowser(global::Foundation.NSNotification notification) => _willEnterVersionBrowser.OnNext(notification); + /// + public override void WillExitFullScreen(global::Foundation.NSNotification notification) => _willExitFullScreen.OnNext(notification); + /// + public override void WillExitVersionBrowser(global::Foundation.NSNotification notification) => _willExitVersionBrowser.OnNext(notification); + /// + public override void WillMiniaturize(global::Foundation.NSNotification notification) => _willMiniaturize.OnNext(notification); + /// + public override void WillMove(global::Foundation.NSNotification notification) => _willMove.OnNext(notification); + /// + public override void WillStartLiveResize(global::Foundation.NSNotification notification) => _willStartLiveResize.OnNext(notification); + } +} + +namespace AuthenticationServices +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class ASAuthorizationControllerDelegateRx : global::AuthenticationServices.ASAuthorizationControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AuthenticationServices.ASAuthorizationController controller, global::AuthenticationServices.ASAuthorization authorization)> _didComplete = new Pharmacist.Common.SingleAwaitSubject<(global::AuthenticationServices.ASAuthorizationController controller, global::AuthenticationServices.ASAuthorization authorization)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AuthenticationServices.ASAuthorizationController controller, global::AuthenticationServices.ASAuthorization authorization)> DidCompleteObs => _didComplete; + /// + public override void DidComplete(global::AuthenticationServices.ASAuthorizationController controller, global::AuthenticationServices.ASAuthorization authorization) => _didComplete.OnNext((controller, authorization)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class ASWebAuthenticationSessionRequestDelegateRx : global::AuthenticationServices.ASWebAuthenticationSessionRequestDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AuthenticationServices.ASWebAuthenticationSessionRequest authenticationSessionRequest, global::Foundation.NSError error)> _didCancel = new Pharmacist.Common.SingleAwaitSubject<(global::AuthenticationServices.ASWebAuthenticationSessionRequest authenticationSessionRequest, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AuthenticationServices.ASWebAuthenticationSessionRequest authenticationSessionRequest, global::Foundation.NSUrl callbackUrl)> _didComplete = new Pharmacist.Common.SingleAwaitSubject<(global::AuthenticationServices.ASWebAuthenticationSessionRequest authenticationSessionRequest, global::Foundation.NSUrl callbackUrl)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AuthenticationServices.ASWebAuthenticationSessionRequest authenticationSessionRequest, global::Foundation.NSError error)> DidCancelObs => _didCancel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AuthenticationServices.ASWebAuthenticationSessionRequest authenticationSessionRequest, global::Foundation.NSUrl callbackUrl)> DidCompleteObs => _didComplete; + /// + public override void DidCancel(global::AuthenticationServices.ASWebAuthenticationSessionRequest authenticationSessionRequest, global::Foundation.NSError error) => _didCancel.OnNext((authenticationSessionRequest, error)); + /// + public override void DidComplete(global::AuthenticationServices.ASWebAuthenticationSessionRequest authenticationSessionRequest, global::Foundation.NSUrl callbackUrl) => _didComplete.OnNext((authenticationSessionRequest, callbackUrl)); + } +} + +namespace AutomaticAssessmentConfiguration +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class AEAssessmentSessionDelegateRx : global::AutomaticAssessmentConfiguration.AEAssessmentSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBegin = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEnd = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error)> _failedToBegin = new Pharmacist.Common.SingleAwaitSubject<(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error)> _wasInterrupted = new Pharmacist.Common.SingleAwaitSubject<(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBeginObs => _didBegin; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndObs => _didEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error)> FailedToBeginObs => _failedToBegin; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error)> WasInterruptedObs => _wasInterrupted; + /// + public override void DidBegin(global::AutomaticAssessmentConfiguration.AEAssessmentSession session) => _didBegin.OnNext(session); + /// + public override void DidEnd(global::AutomaticAssessmentConfiguration.AEAssessmentSession session) => _didEnd.OnNext(session); + /// + public override void FailedToBegin(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error) => _failedToBegin.OnNext((session, error)); + /// + public override void WasInterrupted(global::AutomaticAssessmentConfiguration.AEAssessmentSession session, global::Foundation.NSError error) => _wasInterrupted.OnNext((session, error)); + } +} + +namespace AVFoundation +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class AVAssetResourceLoaderDelegateRx : global::AVFoundation.AVAssetResourceLoaderDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::Foundation.NSUrlAuthenticationChallenge authenticationChallenge)> _didCancelAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::Foundation.NSUrlAuthenticationChallenge authenticationChallenge)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::AVFoundation.AVAssetResourceLoadingRequest loadingRequest)> _didCancelLoadingRequest = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::AVFoundation.AVAssetResourceLoadingRequest loadingRequest)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::Foundation.NSUrlAuthenticationChallenge authenticationChallenge)> DidCancelAuthenticationChallengeObs => _didCancelAuthenticationChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::AVFoundation.AVAssetResourceLoadingRequest loadingRequest)> DidCancelLoadingRequestObs => _didCancelLoadingRequest; + /// + public override void DidCancelAuthenticationChallenge(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::Foundation.NSUrlAuthenticationChallenge authenticationChallenge) => _didCancelAuthenticationChallenge.OnNext((resourceLoader, authenticationChallenge)); + /// + public override void DidCancelLoadingRequest(global::AVFoundation.AVAssetResourceLoader resourceLoader, global::AVFoundation.AVAssetResourceLoadingRequest loadingRequest) => _didCancelLoadingRequest.OnNext((resourceLoader, loadingRequest)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVAssetWriterDelegateRx : global::AVFoundation.AVAssetWriterDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAssetWriter writer, global::Foundation.NSData segmentData, global::AVFoundation.AVAssetSegmentType segmentType, global::AVFoundation.AVAssetSegmentReport segmentReport)> _didOutputSegmentData = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAssetWriter writer, global::Foundation.NSData segmentData, global::AVFoundation.AVAssetSegmentType segmentType, global::AVFoundation.AVAssetSegmentReport segmentReport)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAssetWriter writer, global::Foundation.NSData segmentData, global::AVFoundation.AVAssetSegmentType segmentType, global::AVFoundation.AVAssetSegmentReport segmentReport)> DidOutputSegmentDataObs => _didOutputSegmentData; + /// + public override void DidOutputSegmentData(global::AVFoundation.AVAssetWriter writer, global::Foundation.NSData segmentData, global::AVFoundation.AVAssetSegmentType segmentType, global::AVFoundation.AVAssetSegmentReport segmentReport) => _didOutputSegmentData.OnNext((writer, segmentData, segmentType, segmentReport)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVAudioPlayerDelegateRx : global::AVFoundation.AVAudioPlayerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, global::Foundation.NSError error)> _decoderError = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, bool flag)> _finishedPlaying = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, bool flag)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioPlayer player, global::Foundation.NSError error)> DecoderErrorObs => _decoderError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioPlayer player, bool flag)> FinishedPlayingObs => _finishedPlaying; + /// + public override void DecoderError(global::AVFoundation.AVAudioPlayer player, global::Foundation.NSError error) => _decoderError.OnNext((player, error)); + /// + public override void FinishedPlaying(global::AVFoundation.AVAudioPlayer player, bool flag) => _finishedPlaying.OnNext((player, flag)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVAudioRecorderDelegateRx : global::AVFoundation.AVAudioRecorderDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, global::Foundation.NSError error)> _encoderError = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, bool flag)> _finishedRecording = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, bool flag)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioRecorder recorder, global::Foundation.NSError error)> EncoderErrorObs => _encoderError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioRecorder recorder, bool flag)> FinishedRecordingObs => _finishedRecording; + /// + public override void EncoderError(global::AVFoundation.AVAudioRecorder recorder, global::Foundation.NSError error) => _encoderError.OnNext((recorder, error)); + /// + public override void FinishedRecording(global::AVFoundation.AVAudioRecorder recorder, bool flag) => _finishedRecording.OnNext((recorder, flag)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVCaptureAudioDataOutputSampleBufferDelegateRx : global::AVFoundation.AVCaptureAudioDataOutputSampleBufferDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> _didDropSampleBuffer = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> _didOutputSampleBuffer = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + [global::System.ObsoleteAttribute("This member only exists for 'AVCaptureVideoDataOutputSampleBufferDelegate'.", false)] + public global::System.IObservable<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> DidDropSampleBufferObs => _didDropSampleBuffer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> DidOutputSampleBufferObs => _didOutputSampleBuffer; + /// + [global::System.ObsoleteAttribute("This member only exists for 'AVCaptureVideoDataOutputSampleBufferDelegate'.", false)] + public override void DidDropSampleBuffer(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection) => _didDropSampleBuffer.OnNext((captureOutput, sampleBuffer, connection)); + /// + public override void DidOutputSampleBuffer(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection) => _didOutputSampleBuffer.OnNext((captureOutput, sampleBuffer, connection)); + } + + [global::System.ObsoleteAttribute("This API is not available on this platform.", false)] + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class AVCaptureDataOutputSynchronizerDelegateRx : global::AVFoundation.AVCaptureDataOutputSynchronizerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureDataOutputSynchronizer synchronizer, global::AVFoundation.AVCaptureSynchronizedDataCollection synchronizedDataCollection)> _didOutputSynchronizedDataCollection = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureDataOutputSynchronizer synchronizer, global::AVFoundation.AVCaptureSynchronizedDataCollection synchronizedDataCollection)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureDataOutputSynchronizer synchronizer, global::AVFoundation.AVCaptureSynchronizedDataCollection synchronizedDataCollection)> DidOutputSynchronizedDataCollectionObs => _didOutputSynchronizedDataCollection; + /// + public override void DidOutputSynchronizedDataCollection(global::AVFoundation.AVCaptureDataOutputSynchronizer synchronizer, global::AVFoundation.AVCaptureSynchronizedDataCollection synchronizedDataCollection) => _didOutputSynchronizedDataCollection.OnNext((synchronizer, synchronizedDataCollection)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class AVCaptureFileOutputDelegateRx : global::AVFoundation.AVCaptureFileOutputDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> _didOutputSampleBuffer = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> DidOutputSampleBufferObs => _didOutputSampleBuffer; + /// + public override void DidOutputSampleBuffer(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection) => _didOutputSampleBuffer.OnNext((captureOutput, sampleBuffer, connection)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class AVCaptureFileOutputRecordingDelegateRx : global::AVFoundation.AVCaptureFileOutputRecordingDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureConnection[] connections)> _didPauseRecording = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureConnection[] connections)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureConnection[] connections)> _didResumeRecording = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureConnection[] connections)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections)> _didStartRecording = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections, global::Foundation.NSError error)> _finishedRecording = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureConnection[] connections, global::Foundation.NSError error)> _willFinishRecording = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureConnection[] connections, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureConnection[] connections)> DidPauseRecordingObs => _didPauseRecording; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureConnection[] connections)> DidResumeRecordingObs => _didResumeRecording; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections)> DidStartRecordingObs => _didStartRecording; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections, global::Foundation.NSError error)> FinishedRecordingObs => _finishedRecording; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureConnection[] connections, global::Foundation.NSError error)> WillFinishRecordingObs => _willFinishRecording; + /// + public override void DidPauseRecording(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureConnection[] connections) => _didPauseRecording.OnNext((captureOutput, outputFileUrl, connections)); + /// + public override void DidResumeRecording(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureConnection[] connections) => _didResumeRecording.OnNext((captureOutput, outputFileUrl, connections)); + /// + public override void DidStartRecording(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections) => _didStartRecording.OnNext((captureOutput, outputFileUrl, connections)); + /// + public override void FinishedRecording(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::Foundation.NSObject[] connections, global::Foundation.NSError error) => _finishedRecording.OnNext((captureOutput, outputFileUrl, connections, error)); + /// + public override void WillFinishRecording(global::AVFoundation.AVCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileUrl, global::AVFoundation.AVCaptureConnection[] connections, global::Foundation.NSError error) => _willFinishRecording.OnNext((captureOutput, outputFileUrl, connections, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVCapturePhotoCaptureDelegateRx : global::AVFoundation.AVCapturePhotoCaptureDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)> _didCapturePhoto = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::Foundation.NSError error)> _didFinishCapture = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput output, global::AVFoundation.AVCapturePhoto photo, global::Foundation.NSError error)> _didFinishProcessingPhoto = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput output, global::AVFoundation.AVCapturePhoto photo, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)> _willBeginCapture = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)> _willCapturePhoto = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)> DidCapturePhotoObs => _didCapturePhoto; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::Foundation.NSError error)> DidFinishCaptureObs => _didFinishCapture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCapturePhotoOutput output, global::AVFoundation.AVCapturePhoto photo, global::Foundation.NSError error)> DidFinishProcessingPhotoObs => _didFinishProcessingPhoto; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)> WillBeginCaptureObs => _willBeginCapture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings)> WillCapturePhotoObs => _willCapturePhoto; + /// + public override void DidCapturePhoto(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings) => _didCapturePhoto.OnNext((captureOutput, resolvedSettings)); + /// + public override void DidFinishCapture(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings, global::Foundation.NSError error) => _didFinishCapture.OnNext((captureOutput, resolvedSettings, error)); + /// + public override void DidFinishProcessingPhoto(global::AVFoundation.AVCapturePhotoOutput output, global::AVFoundation.AVCapturePhoto photo, global::Foundation.NSError error) => _didFinishProcessingPhoto.OnNext((output, photo, error)); + /// + public override void WillBeginCapture(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings) => _willBeginCapture.OnNext((captureOutput, resolvedSettings)); + /// + public override void WillCapturePhoto(global::AVFoundation.AVCapturePhotoOutput captureOutput, global::AVFoundation.AVCaptureResolvedPhotoSettings resolvedSettings) => _willCapturePhoto.OnNext((captureOutput, resolvedSettings)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVCaptureVideoDataOutputSampleBufferDelegateRx : global::AVFoundation.AVCaptureVideoDataOutputSampleBufferDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> _didDropSampleBuffer = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> _didOutputSampleBuffer = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> DidDropSampleBufferObs => _didDropSampleBuffer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection)> DidOutputSampleBufferObs => _didOutputSampleBuffer; + /// + public override void DidDropSampleBuffer(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection) => _didDropSampleBuffer.OnNext((captureOutput, sampleBuffer, connection)); + /// + public override void DidOutputSampleBuffer(global::AVFoundation.AVCaptureOutput captureOutput, global::CoreMedia.CMSampleBuffer sampleBuffer, global::AVFoundation.AVCaptureConnection connection) => _didOutputSampleBuffer.OnNext((captureOutput, sampleBuffer, connection)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class AVContentKeySessionDelegateRx : global::AVFoundation.AVContentKeySessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest, global::Foundation.NSError err)> _didFail = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest, global::Foundation.NSError err)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didGenerateExpiredSessionReport = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> _didProvideContentKeyRequest = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVPersistableContentKeyRequest keyRequest)> _didProvidePersistableContentKeyRequest = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVPersistableContentKeyRequest keyRequest)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> _didProvideRenewingContentKeyRequest = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> _didSucceed = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::Foundation.NSData persistableContentKey, global::Foundation.NSObject keyIdentifier)> _didUpdate = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::Foundation.NSData persistableContentKey, global::Foundation.NSObject keyIdentifier)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeObs => _didChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest, global::Foundation.NSError err)> DidFailObs => _didFail; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidGenerateExpiredSessionReportObs => _didGenerateExpiredSessionReport; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> DidProvideContentKeyRequestObs => _didProvideContentKeyRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVPersistableContentKeyRequest keyRequest)> DidProvidePersistableContentKeyRequestObs => _didProvidePersistableContentKeyRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> DidProvideRenewingContentKeyRequestObs => _didProvideRenewingContentKeyRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> DidSucceedObs => _didSucceed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::Foundation.NSData persistableContentKey, global::Foundation.NSObject keyIdentifier)> DidUpdateObs => _didUpdate; + /// + public override void DidChange(global::AVFoundation.AVContentKeySession session) => _didChange.OnNext(session); + /// + public override void DidFail(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest, global::Foundation.NSError err) => _didFail.OnNext((session, keyRequest, err)); + /// + public override void DidGenerateExpiredSessionReport(global::AVFoundation.AVContentKeySession session) => _didGenerateExpiredSessionReport.OnNext(session); + /// + public override void DidProvideContentKeyRequest(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest) => _didProvideContentKeyRequest.OnNext((session, keyRequest)); + /// + public override void DidProvidePersistableContentKeyRequest(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVPersistableContentKeyRequest keyRequest) => _didProvidePersistableContentKeyRequest.OnNext((session, keyRequest)); + /// + public override void DidProvideRenewingContentKeyRequest(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest) => _didProvideRenewingContentKeyRequest.OnNext((session, keyRequest)); + /// + public override void DidSucceed(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest) => _didSucceed.OnNext((session, keyRequest)); + /// + public override void DidUpdate(global::AVFoundation.AVContentKeySession session, global::Foundation.NSData persistableContentKey, global::Foundation.NSObject keyIdentifier) => _didUpdate.OnNext((session, persistableContentKey, keyIdentifier)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class AVPlayerItemMetadataCollectorPushDelegateRx : global::AVFoundation.AVPlayerItemMetadataCollectorPushDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVPlayerItemMetadataCollector metadataCollector, global::AVFoundation.AVDateRangeMetadataGroup[] metadataGroups, global::Foundation.NSIndexSet indexesOfNewGroups, global::Foundation.NSIndexSet indexesOfModifiedGroups)> _didCollectDateRange = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVPlayerItemMetadataCollector metadataCollector, global::AVFoundation.AVDateRangeMetadataGroup[] metadataGroups, global::Foundation.NSIndexSet indexesOfNewGroups, global::Foundation.NSIndexSet indexesOfModifiedGroups)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVPlayerItemMetadataCollector metadataCollector, global::AVFoundation.AVDateRangeMetadataGroup[] metadataGroups, global::Foundation.NSIndexSet indexesOfNewGroups, global::Foundation.NSIndexSet indexesOfModifiedGroups)> DidCollectDateRangeObs => _didCollectDateRange; + /// + public override void DidCollectDateRange(global::AVFoundation.AVPlayerItemMetadataCollector metadataCollector, global::AVFoundation.AVDateRangeMetadataGroup[] metadataGroups, global::Foundation.NSIndexSet indexesOfNewGroups, global::Foundation.NSIndexSet indexesOfModifiedGroups) => _didCollectDateRange.OnNext((metadataCollector, metadataGroups, indexesOfNewGroups, indexesOfModifiedGroups)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVPlayerItemMetadataOutputPushDelegateRx : global::AVFoundation.AVPlayerItemMetadataOutputPushDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVPlayerItemMetadataOutput output, global::AVFoundation.AVTimedMetadataGroup[] groups, global::AVFoundation.AVPlayerItemTrack track)> _didOutputTimedMetadataGroups = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVPlayerItemMetadataOutput output, global::AVFoundation.AVTimedMetadataGroup[] groups, global::AVFoundation.AVPlayerItemTrack track)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _outputSequenceWasFlushed = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVPlayerItemMetadataOutput output, global::AVFoundation.AVTimedMetadataGroup[] groups, global::AVFoundation.AVPlayerItemTrack track)> DidOutputTimedMetadataGroupsObs => _didOutputTimedMetadataGroups; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OutputSequenceWasFlushedObs => _outputSequenceWasFlushed; + /// + public override void DidOutputTimedMetadataGroups(global::AVFoundation.AVPlayerItemMetadataOutput output, global::AVFoundation.AVTimedMetadataGroup[] groups, global::AVFoundation.AVPlayerItemTrack track) => _didOutputTimedMetadataGroups.OnNext((output, groups, track)); + /// + public override void OutputSequenceWasFlushed(global::AVFoundation.AVPlayerItemOutput output) => _outputSequenceWasFlushed.OnNext(output); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVPlayerItemOutputPullDelegateRx : global::AVFoundation.AVPlayerItemOutputPullDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _outputMediaDataWillChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _outputSequenceWasFlushed = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OutputMediaDataWillChangeObs => _outputMediaDataWillChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OutputSequenceWasFlushedObs => _outputSequenceWasFlushed; + /// + public override void OutputMediaDataWillChange(global::AVFoundation.AVPlayerItemOutput sender) => _outputMediaDataWillChange.OnNext(sender); + /// + public override void OutputSequenceWasFlushed(global::AVFoundation.AVPlayerItemOutput output) => _outputSequenceWasFlushed.OnNext(output); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVPlayerItemOutputPushDelegateRx : global::AVFoundation.AVPlayerItemOutputPushDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _outputSequenceWasFlushed = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OutputSequenceWasFlushedObs => _outputSequenceWasFlushed; + /// + public override void OutputSequenceWasFlushed(global::AVFoundation.AVPlayerItemOutput output) => _outputSequenceWasFlushed.OnNext(output); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVSpeechSynthesizerDelegateRx : global::AVFoundation.AVSpeechSynthesizerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> _didCancelSpeechUtterance = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> _didContinueSpeechUtterance = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> _didFinishSpeechUtterance = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> _didPauseSpeechUtterance = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> _didStartSpeechUtterance = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::Foundation.NSRange characterRange, global::AVFoundation.AVSpeechUtterance utterance)> _willSpeakRangeOfSpeechString = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::Foundation.NSRange characterRange, global::AVFoundation.AVSpeechUtterance utterance)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> DidCancelSpeechUtteranceObs => _didCancelSpeechUtterance; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> DidContinueSpeechUtteranceObs => _didContinueSpeechUtterance; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> DidFinishSpeechUtteranceObs => _didFinishSpeechUtterance; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> DidPauseSpeechUtteranceObs => _didPauseSpeechUtterance; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> DidStartSpeechUtteranceObs => _didStartSpeechUtterance; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::Foundation.NSRange characterRange, global::AVFoundation.AVSpeechUtterance utterance)> WillSpeakRangeOfSpeechStringObs => _willSpeakRangeOfSpeechString; + /// + public override void DidCancelSpeechUtterance(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance) => _didCancelSpeechUtterance.OnNext((synthesizer, utterance)); + /// + public override void DidContinueSpeechUtterance(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance) => _didContinueSpeechUtterance.OnNext((synthesizer, utterance)); + /// + public override void DidFinishSpeechUtterance(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance) => _didFinishSpeechUtterance.OnNext((synthesizer, utterance)); + /// + public override void DidPauseSpeechUtterance(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance) => _didPauseSpeechUtterance.OnNext((synthesizer, utterance)); + /// + public override void DidStartSpeechUtterance(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance) => _didStartSpeechUtterance.OnNext((synthesizer, utterance)); + /// + public override void WillSpeakRangeOfSpeechString(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::Foundation.NSRange characterRange, global::AVFoundation.AVSpeechUtterance utterance) => _willSpeakRangeOfSpeechString.OnNext((synthesizer, characterRange, utterance)); + } +} + +namespace AVKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class AVCaptureViewDelegateRx : global::AVKit.AVCaptureViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVCaptureView captureView, global::AVFoundation.AVCaptureFileOutput fileOutput)> _startRecording = new Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVCaptureView captureView, global::AVFoundation.AVCaptureFileOutput fileOutput)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVKit.AVCaptureView captureView, global::AVFoundation.AVCaptureFileOutput fileOutput)> StartRecordingObs => _startRecording; + /// + public override void StartRecording(global::AVKit.AVCaptureView captureView, global::AVFoundation.AVCaptureFileOutput fileOutput) => _startRecording.OnNext((captureView, fileOutput)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVPictureInPictureControllerDelegateRx : global::AVKit.AVPictureInPictureControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didStartPictureInPicture = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didStopPictureInPicture = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPictureInPictureController pictureInPictureController, global::Foundation.NSError error)> _failedToStartPictureInPicture = new Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPictureInPictureController pictureInPictureController, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPictureInPictureController pictureInPictureController, global::System.Action completionHandler)> _restoreUserInterfaceForPictureInPicture = new Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPictureInPictureController pictureInPictureController, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStartPictureInPicture = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStopPictureInPicture = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidStartPictureInPictureObs => _didStartPictureInPicture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidStopPictureInPictureObs => _didStopPictureInPicture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVKit.AVPictureInPictureController pictureInPictureController, global::Foundation.NSError error)> FailedToStartPictureInPictureObs => _failedToStartPictureInPicture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVKit.AVPictureInPictureController pictureInPictureController, global::System.Action completionHandler)> RestoreUserInterfaceForPictureInPictureObs => _restoreUserInterfaceForPictureInPicture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStartPictureInPictureObs => _willStartPictureInPicture; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStopPictureInPictureObs => _willStopPictureInPicture; + /// + public override void DidStartPictureInPicture(global::AVKit.AVPictureInPictureController pictureInPictureController) => _didStartPictureInPicture.OnNext(pictureInPictureController); + /// + public override void DidStopPictureInPicture(global::AVKit.AVPictureInPictureController pictureInPictureController) => _didStopPictureInPicture.OnNext(pictureInPictureController); + /// + public override void FailedToStartPictureInPicture(global::AVKit.AVPictureInPictureController pictureInPictureController, global::Foundation.NSError error) => _failedToStartPictureInPicture.OnNext((pictureInPictureController, error)); + /// + public override void RestoreUserInterfaceForPictureInPicture(global::AVKit.AVPictureInPictureController pictureInPictureController, global::System.Action completionHandler) => _restoreUserInterfaceForPictureInPicture.OnNext((pictureInPictureController, completionHandler)); + /// + public override void WillStartPictureInPicture(global::AVKit.AVPictureInPictureController pictureInPictureController) => _willStartPictureInPicture.OnNext(pictureInPictureController); + /// + public override void WillStopPictureInPicture(global::AVKit.AVPictureInPictureController pictureInPictureController) => _willStopPictureInPicture.OnNext(pictureInPictureController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVPlayerViewPictureInPictureDelegateRx : global::AVKit.AVPlayerViewPictureInPictureDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didStart = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didStop = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPlayerView playerView, global::Foundation.NSError error)> _failedToStart = new Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPlayerView playerView, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPlayerView playerView, global::System.Action completionHandler)> _restoreUserInterface = new Pharmacist.Common.SingleAwaitSubject<(global::AVKit.AVPlayerView playerView, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStart = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStop = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidStartObs => _didStart; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidStopObs => _didStop; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVKit.AVPlayerView playerView, global::Foundation.NSError error)> FailedToStartObs => _failedToStart; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVKit.AVPlayerView playerView, global::System.Action completionHandler)> RestoreUserInterfaceObs => _restoreUserInterface; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStartObs => _willStart; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStopObs => _willStop; + /// + public override void DidStart(global::AVKit.AVPlayerView playerView) => _didStart.OnNext(playerView); + /// + public override void DidStop(global::AVKit.AVPlayerView playerView) => _didStop.OnNext(playerView); + /// + public override void FailedToStart(global::AVKit.AVPlayerView playerView, global::Foundation.NSError error) => _failedToStart.OnNext((playerView, error)); + /// + public override void RestoreUserInterface(global::AVKit.AVPlayerView playerView, global::System.Action completionHandler) => _restoreUserInterface.OnNext((playerView, completionHandler)); + /// + public override void WillStart(global::AVKit.AVPlayerView playerView) => _willStart.OnNext(playerView); + /// + public override void WillStop(global::AVKit.AVPlayerView playerView) => _willStop.OnNext(playerView); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVRoutePickerViewDelegateRx : global::AVKit.AVRoutePickerViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didEndPresentingRoutes = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willBeginPresentingRoutes = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndPresentingRoutesObs => _didEndPresentingRoutes; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillBeginPresentingRoutesObs => _willBeginPresentingRoutes; + /// + public override void DidEndPresentingRoutes(global::AVKit.AVRoutePickerView routePickerView) => _didEndPresentingRoutes.OnNext(routePickerView); + /// + public override void WillBeginPresentingRoutes(global::AVKit.AVRoutePickerView routePickerView) => _willBeginPresentingRoutes.OnNext(routePickerView); + } +} + +namespace ContactsUI +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class CNContactPickerDelegateRx : global::ContactsUI.CNContactPickerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ContactsUI.CNContactPicker picker, global::Contacts.CNContactProperty contactProperty)> _contactPropertySelected = new Pharmacist.Common.SingleAwaitSubject<(global::ContactsUI.CNContactPicker picker, global::Contacts.CNContactProperty contactProperty)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ContactsUI.CNContactPicker picker, global::Contacts.CNContact contact)> _contactSelected = new Pharmacist.Common.SingleAwaitSubject<(global::ContactsUI.CNContactPicker picker, global::Contacts.CNContact contact)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didClose = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willClose = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ContactsUI.CNContactPicker picker, global::Contacts.CNContactProperty contactProperty)> ContactPropertySelectedObs => _contactPropertySelected; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ContactsUI.CNContactPicker picker, global::Contacts.CNContact contact)> ContactSelectedObs => _contactSelected; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidCloseObs => _didClose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillCloseObs => _willClose; + /// + public override void ContactPropertySelected(global::ContactsUI.CNContactPicker picker, global::Contacts.CNContactProperty contactProperty) => _contactPropertySelected.OnNext((picker, contactProperty)); + /// + public override void ContactSelected(global::ContactsUI.CNContactPicker picker, global::Contacts.CNContact contact) => _contactSelected.OnNext((picker, contact)); + /// + public override void DidClose(global::ContactsUI.CNContactPicker picker) => _didClose.OnNext(picker); + /// + public override void WillClose(global::ContactsUI.CNContactPicker picker) => _willClose.OnNext(picker); + } +} + +namespace CoreAnimation +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class CAAnimationDelegateRx : global::CoreAnimation.CAAnimationDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _animationStarted = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreAnimation.CAAnimation anim, bool finished)> _animationStopped = new Pharmacist.Common.SingleAwaitSubject<(global::CoreAnimation.CAAnimation anim, bool finished)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable AnimationStartedObs => _animationStarted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreAnimation.CAAnimation anim, bool finished)> AnimationStoppedObs => _animationStopped; + /// + public override void AnimationStarted(global::CoreAnimation.CAAnimation anim) => _animationStarted.OnNext(anim); + /// + public override void AnimationStopped(global::CoreAnimation.CAAnimation anim, bool finished) => _animationStopped.OnNext((anim, finished)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class CALayerDelegateRx : global::CoreAnimation.CALayerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _displayLayer = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreAnimation.CALayer layer, global::CoreGraphics.CGContext context)> _drawLayer = new Pharmacist.Common.SingleAwaitSubject<(global::CoreAnimation.CALayer layer, global::CoreGraphics.CGContext context)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _layoutSublayersOfLayer = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willDrawLayer = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DisplayLayerObs => _displayLayer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreAnimation.CALayer layer, global::CoreGraphics.CGContext context)> DrawLayerObs => _drawLayer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LayoutSublayersOfLayerObs => _layoutSublayersOfLayer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillDrawLayerObs => _willDrawLayer; + /// + public override void DisplayLayer(global::CoreAnimation.CALayer layer) => _displayLayer.OnNext(layer); + /// + public override void DrawLayer(global::CoreAnimation.CALayer layer, global::CoreGraphics.CGContext context) => _drawLayer.OnNext((layer, context)); + /// + public override void LayoutSublayersOfLayer(global::CoreAnimation.CALayer layer) => _layoutSublayersOfLayer.OnNext(layer); + /// + public override void WillDrawLayer(global::CoreAnimation.CALayer layer) => _willDrawLayer.OnNext(layer); + } +} + +namespace CoreBluetooth +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CBCentralManagerDelegateRx : global::CoreBluetooth.CBCentralManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral)> _connectedPeripheral = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> _disconnectedPeripheral = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSDictionary advertisementData, global::Foundation.NSNumber RSSI)> _discoveredPeripheral = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSDictionary advertisementData, global::Foundation.NSNumber RSSI)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> _failedToConnectPeripheral = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals)> _retrievedConnectedPeripherals = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals)> _retrievedPeripherals = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _updatedState = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::Foundation.NSDictionary dict)> _willRestoreState = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::Foundation.NSDictionary dict)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral)> ConnectedPeripheralObs => _connectedPeripheral; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> DisconnectedPeripheralObs => _disconnectedPeripheral; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSDictionary advertisementData, global::Foundation.NSNumber RSSI)> DiscoveredPeripheralObs => _discoveredPeripheral; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> FailedToConnectPeripheralObs => _failedToConnectPeripheral; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals)> RetrievedConnectedPeripheralsObs => _retrievedConnectedPeripherals; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals)> RetrievedPeripheralsObs => _retrievedPeripherals; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UpdatedStateObs => _updatedState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::Foundation.NSDictionary dict)> WillRestoreStateObs => _willRestoreState; + /// + public override void ConnectedPeripheral(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral) => _connectedPeripheral.OnNext((central, peripheral)); + /// + public override void DisconnectedPeripheral(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error) => _disconnectedPeripheral.OnNext((central, peripheral, error)); + /// + public override void DiscoveredPeripheral(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSDictionary advertisementData, global::Foundation.NSNumber RSSI) => _discoveredPeripheral.OnNext((central, peripheral, advertisementData, RSSI)); + /// + public override void FailedToConnectPeripheral(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error) => _failedToConnectPeripheral.OnNext((central, peripheral, error)); + /// + public override void RetrievedConnectedPeripherals(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals) => _retrievedConnectedPeripherals.OnNext((central, peripherals)); + /// + public override void RetrievedPeripherals(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral[] peripherals) => _retrievedPeripherals.OnNext((central, peripherals)); + /// + public override void UpdatedState(global::CoreBluetooth.CBCentralManager central) => _updatedState.OnNext(central); + /// + public override void WillRestoreState(global::CoreBluetooth.CBCentralManager central, global::Foundation.NSDictionary dict) => _willRestoreState.OnNext((central, dict)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class CBPeripheralDelegateRx : global::CoreBluetooth.CBPeripheralDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)> _didOpenL2CapChannel = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> _discoveredCharacteristic = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> _discoveredDescriptor = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> _discoveredIncludedService = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> _discoveredService = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _invalidatedService = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _isReadyToSendWriteWithoutResponse = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService[] services)> _modifiedServices = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService[] services)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSNumber rssi, global::Foundation.NSError error)> _rssiRead = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSNumber rssi, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> _rssiUpdated = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> _updatedCharacterteristicValue = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _updatedName = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> _updatedNotificationState = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)> _updatedValue = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> _wroteCharacteristicValue = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)> _wroteDescriptorValue = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)> DidOpenL2CapChannelObs => _didOpenL2CapChannel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> DiscoveredCharacteristicObs => _discoveredCharacteristic; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> DiscoveredDescriptorObs => _discoveredDescriptor; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> DiscoveredIncludedServiceObs => _discoveredIncludedService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> DiscoveredServiceObs => _discoveredService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable InvalidatedServiceObs => _invalidatedService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable IsReadyToSendWriteWithoutResponseObs => _isReadyToSendWriteWithoutResponse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService[] services)> ModifiedServicesObs => _modifiedServices; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSNumber rssi, global::Foundation.NSError error)> RssiReadObs => _rssiRead; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> RssiUpdatedObs => _rssiUpdated; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> UpdatedCharacterteristicValueObs => _updatedCharacterteristicValue; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UpdatedNameObs => _updatedName; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> UpdatedNotificationStateObs => _updatedNotificationState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)> UpdatedValueObs => _updatedValue; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> WroteCharacteristicValueObs => _wroteCharacteristicValue; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)> WroteDescriptorValueObs => _wroteDescriptorValue; + /// + public override void DidOpenL2CapChannel(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error) => _didOpenL2CapChannel.OnNext((peripheral, channel, error)); + /// + public override void DiscoveredCharacteristic(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error) => _discoveredCharacteristic.OnNext((peripheral, service, error)); + /// + public override void DiscoveredDescriptor(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error) => _discoveredDescriptor.OnNext((peripheral, characteristic, error)); + /// + public override void DiscoveredIncludedService(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error) => _discoveredIncludedService.OnNext((peripheral, service, error)); + /// + public override void DiscoveredService(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error) => _discoveredService.OnNext((peripheral, error)); + /// + public override void InvalidatedService(global::CoreBluetooth.CBPeripheral peripheral) => _invalidatedService.OnNext(peripheral); + /// + public override void IsReadyToSendWriteWithoutResponse(global::CoreBluetooth.CBPeripheral peripheral) => _isReadyToSendWriteWithoutResponse.OnNext(peripheral); + /// + public override void ModifiedServices(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService[] services) => _modifiedServices.OnNext((peripheral, services)); + /// + public override void RssiRead(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSNumber rssi, global::Foundation.NSError error) => _rssiRead.OnNext((peripheral, rssi, error)); + /// + public override void RssiUpdated(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error) => _rssiUpdated.OnNext((peripheral, error)); + /// + public override void UpdatedCharacterteristicValue(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error) => _updatedCharacterteristicValue.OnNext((peripheral, characteristic, error)); + /// + public override void UpdatedName(global::CoreBluetooth.CBPeripheral peripheral) => _updatedName.OnNext(peripheral); + /// + public override void UpdatedNotificationState(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error) => _updatedNotificationState.OnNext((peripheral, characteristic, error)); + /// + public override void UpdatedValue(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error) => _updatedValue.OnNext((peripheral, descriptor, error)); + /// + public override void WroteCharacteristicValue(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error) => _wroteCharacteristicValue.OnNext((peripheral, characteristic, error)); + /// + public override void WroteDescriptorValue(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error) => _wroteDescriptorValue.OnNext((peripheral, descriptor, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CBPeripheralManagerDelegateRx : global::CoreBluetooth.CBPeripheralManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSError error)> _advertisingStarted = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)> _characteristicSubscribed = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)> _characteristicUnsubscribed = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)> _didOpenL2CapChannel = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)> _didPublishL2CapChannel = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)> _didUnpublishL2CapChannel = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest request)> _readRequestReceived = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest request)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _readyToUpdateSubscribers = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> _serviceAdded = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _stateUpdated = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSDictionary dict)> _willRestoreState = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSDictionary dict)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest[] requests)> _writeRequestsReceived = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest[] requests)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSError error)> AdvertisingStartedObs => _advertisingStarted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)> CharacteristicSubscribedObs => _characteristicSubscribed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)> CharacteristicUnsubscribedObs => _characteristicUnsubscribed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)> DidOpenL2CapChannelObs => _didOpenL2CapChannel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)> DidPublishL2CapChannelObs => _didPublishL2CapChannel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)> DidUnpublishL2CapChannelObs => _didUnpublishL2CapChannel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest request)> ReadRequestReceivedObs => _readRequestReceived; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ReadyToUpdateSubscribersObs => _readyToUpdateSubscribers; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> ServiceAddedObs => _serviceAdded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable StateUpdatedObs => _stateUpdated; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSDictionary dict)> WillRestoreStateObs => _willRestoreState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest[] requests)> WriteRequestsReceivedObs => _writeRequestsReceived; + /// + public override void AdvertisingStarted(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSError error) => _advertisingStarted.OnNext((peripheral, error)); + /// + public override void CharacteristicSubscribed(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic) => _characteristicSubscribed.OnNext((peripheral, central, characteristic)); + /// + public override void CharacteristicUnsubscribed(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic) => _characteristicUnsubscribed.OnNext((peripheral, central, characteristic)); + /// + public override void DidOpenL2CapChannel(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error) => _didOpenL2CapChannel.OnNext((peripheral, channel, error)); + /// + public override void DidPublishL2CapChannel(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error) => _didPublishL2CapChannel.OnNext((peripheral, psm, error)); + /// + public override void DidUnpublishL2CapChannel(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error) => _didUnpublishL2CapChannel.OnNext((peripheral, psm, error)); + /// + public override void ReadRequestReceived(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest request) => _readRequestReceived.OnNext((peripheral, request)); + /// + public override void ReadyToUpdateSubscribers(global::CoreBluetooth.CBPeripheralManager peripheral) => _readyToUpdateSubscribers.OnNext(peripheral); + /// + public override void ServiceAdded(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error) => _serviceAdded.OnNext((peripheral, service, error)); + /// + public override void StateUpdated(global::CoreBluetooth.CBPeripheralManager peripheral) => _stateUpdated.OnNext(peripheral); + /// + public override void WillRestoreState(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSDictionary dict) => _willRestoreState.OnNext((peripheral, dict)); + /// + public override void WriteRequestsReceived(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest[] requests) => _writeRequestsReceived.OnNext((peripheral, requests)); + } +} + +namespace CoreData +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSCoreDataCoreSpotlightDelegateRx : global::CoreData.NSCoreDataCoreSpotlightDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler)> _reindexAllSearchableItems = new Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler)> _reindexSearchableItems = new Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler)> ReindexAllSearchableItemsObs => _reindexAllSearchableItems; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler)> ReindexSearchableItemsObs => _reindexSearchableItems; + /// + public override void ReindexAllSearchableItems(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler) => _reindexAllSearchableItems.OnNext((searchableIndex, acknowledgementHandler)); + /// + public override void ReindexSearchableItems(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler) => _reindexSearchableItems.OnNext((searchableIndex, identifiers, acknowledgementHandler)); + } +} + +namespace CoreLocation +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class CLLocationManagerDelegateRx : global::CoreLocation.CLLocationManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLAuthorizationStatus status)> _authorizationChanged = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLAuthorizationStatus status)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error)> _deferredUpdatesFinished = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeAuthorization = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegionState state, global::CoreLocation.CLRegion region)> _didDetermineState = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegionState state, global::CoreLocation.CLRegion region)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint, global::Foundation.NSError error)> _didFailRangingBeacons = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeacon[] beacons, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint)> _didRangeBeaconsSatisfyingConstraint = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeacon[] beacons, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)> _didStartMonitoringForRegion = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLVisit visit)> _didVisit = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLVisit visit)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error)> _failed = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation[] locations)> _locationsUpdated = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation[] locations)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _locationUpdatesPaused = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _locationUpdatesResumed = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region, global::Foundation.NSError error)> _monitoringFailed = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)> _regionEntered = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)> _regionLeft = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLHeading newHeading)> _updatedHeading = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLHeading newHeading)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation newLocation, global::CoreLocation.CLLocation oldLocation)> _updatedLocation = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation newLocation, global::CoreLocation.CLLocation oldLocation)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLAuthorizationStatus status)> AuthorizationChangedObs => _authorizationChanged; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error)> DeferredUpdatesFinishedObs => _deferredUpdatesFinished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeAuthorizationObs => _didChangeAuthorization; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegionState state, global::CoreLocation.CLRegion region)> DidDetermineStateObs => _didDetermineState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint, global::Foundation.NSError error)> DidFailRangingBeaconsObs => _didFailRangingBeacons; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeacon[] beacons, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint)> DidRangeBeaconsSatisfyingConstraintObs => _didRangeBeaconsSatisfyingConstraint; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)> DidStartMonitoringForRegionObs => _didStartMonitoringForRegion; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLVisit visit)> DidVisitObs => _didVisit; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error)> FailedObs => _failed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation[] locations)> LocationsUpdatedObs => _locationsUpdated; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LocationUpdatesPausedObs => _locationUpdatesPaused; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LocationUpdatesResumedObs => _locationUpdatesResumed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region, global::Foundation.NSError error)> MonitoringFailedObs => _monitoringFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)> RegionEnteredObs => _regionEntered; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region)> RegionLeftObs => _regionLeft; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLHeading newHeading)> UpdatedHeadingObs => _updatedHeading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation newLocation, global::CoreLocation.CLLocation oldLocation)> UpdatedLocationObs => _updatedLocation; + /// + public override void AuthorizationChanged(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLAuthorizationStatus status) => _authorizationChanged.OnNext((manager, status)); + /// + public override void DeferredUpdatesFinished(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error) => _deferredUpdatesFinished.OnNext((manager, error)); + /// + public override void DidChangeAuthorization(global::CoreLocation.CLLocationManager manager) => _didChangeAuthorization.OnNext(manager); + /// + public override void DidDetermineState(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegionState state, global::CoreLocation.CLRegion region) => _didDetermineState.OnNext((manager, state, region)); + /// + public override void DidFailRangingBeacons(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint, global::Foundation.NSError error) => _didFailRangingBeacons.OnNext((manager, beaconConstraint, error)); + /// + public override void DidRangeBeaconsSatisfyingConstraint(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLBeacon[] beacons, global::CoreLocation.CLBeaconIdentityConstraint beaconConstraint) => _didRangeBeaconsSatisfyingConstraint.OnNext((manager, beacons, beaconConstraint)); + /// + public override void DidStartMonitoringForRegion(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region) => _didStartMonitoringForRegion.OnNext((manager, region)); + /// + public override void DidVisit(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLVisit visit) => _didVisit.OnNext((manager, visit)); + /// + public override void Failed(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error) => _failed.OnNext((manager, error)); + /// + public override void LocationsUpdated(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation[] locations) => _locationsUpdated.OnNext((manager, locations)); + /// + public override void LocationUpdatesPaused(global::CoreLocation.CLLocationManager manager) => _locationUpdatesPaused.OnNext(manager); + /// + public override void LocationUpdatesResumed(global::CoreLocation.CLLocationManager manager) => _locationUpdatesResumed.OnNext(manager); + /// + public override void MonitoringFailed(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region, global::Foundation.NSError error) => _monitoringFailed.OnNext((manager, region, error)); + /// + public override void RegionEntered(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region) => _regionEntered.OnNext((manager, region)); + /// + public override void RegionLeft(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLRegion region) => _regionLeft.OnNext((manager, region)); + /// + public override void UpdatedHeading(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLHeading newHeading) => _updatedHeading.OnNext((manager, newHeading)); + /// + public override void UpdatedLocation(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation newLocation, global::CoreLocation.CLLocation oldLocation) => _updatedLocation.OnNext((manager, newLocation, oldLocation)); + } +} + +namespace CoreMidi +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class MidiCIProfileResponderDelegateRx : global::CoreMidi.MidiCIProfileResponderDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreMidi.MidiCIProfile profile, byte channel, global::Foundation.NSData inData)> _handleData = new Pharmacist.Common.SingleAwaitSubject<(global::CoreMidi.MidiCIProfile profile, byte channel, global::Foundation.NSData inData)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _initiatorDisconnected = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreMidi.MidiCIProfile profile, byte channel, global::Foundation.NSData inData)> HandleDataObs => _handleData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable InitiatorDisconnectedObs => _initiatorDisconnected; + /// + public override void HandleData(global::CoreMidi.MidiCIProfile profile, byte channel, global::Foundation.NSData inData) => _handleData.OnNext((profile, channel, inData)); + /// + public override void InitiatorDisconnected(global::Foundation.NSNumber initiatorMuid) => _initiatorDisconnected.OnNext(initiatorMuid); + } +} + +namespace CoreSpotlight +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CSSearchableIndexDelegateRx : global::CoreSpotlight.CSSearchableIndexDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didFinishThrottle = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didThrottle = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler)> _reindexAllSearchableItems = new Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler)> _reindexSearchableItems = new Pharmacist.Common.SingleAwaitSubject<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishThrottleObs => _didFinishThrottle; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidThrottleObs => _didThrottle; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler)> ReindexAllSearchableItemsObs => _reindexAllSearchableItems; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler)> ReindexSearchableItemsObs => _reindexSearchableItems; + /// + public override void DidFinishThrottle(global::CoreSpotlight.CSSearchableIndex searchableIndex) => _didFinishThrottle.OnNext(searchableIndex); + /// + public override void DidThrottle(global::CoreSpotlight.CSSearchableIndex searchableIndex) => _didThrottle.OnNext(searchableIndex); + /// + public override void ReindexAllSearchableItems(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.Action acknowledgementHandler) => _reindexAllSearchableItems.OnNext((searchableIndex, acknowledgementHandler)); + /// + public override void ReindexSearchableItems(global::CoreSpotlight.CSSearchableIndex searchableIndex, global::System.String[] identifiers, global::System.Action acknowledgementHandler) => _reindexSearchableItems.OnNext((searchableIndex, identifiers, acknowledgementHandler)); + } +} + +namespace CoreWlan +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class CWEventDelegateRx : global::CoreWlan.CWEventDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _bssidDidChangeForWiFi = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _clientConnectionInterrupted = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _clientConnectionInvalidated = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _countryCodeDidChangeForWiFi = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _linkDidChangeForWiFi = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(string interfaceName, int rssi, double transmitRate)> _linkQualityDidChangeForWiFi = new Pharmacist.Common.SingleAwaitSubject<(string interfaceName, int rssi, double transmitRate)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _modeDidChangeForWiFi = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _powerStateDidChangeForWiFi = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _scanCacheUpdatedForWiFi = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _ssidDidChangeForWiFi = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable BssidDidChangeForWiFiObs => _bssidDidChangeForWiFi; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ClientConnectionInterruptedObs => _clientConnectionInterrupted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ClientConnectionInvalidatedObs => _clientConnectionInvalidated; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable CountryCodeDidChangeForWiFiObs => _countryCodeDidChangeForWiFi; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LinkDidChangeForWiFiObs => _linkDidChangeForWiFi; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(string interfaceName, int rssi, double transmitRate)> LinkQualityDidChangeForWiFiObs => _linkQualityDidChangeForWiFi; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ModeDidChangeForWiFiObs => _modeDidChangeForWiFi; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PowerStateDidChangeForWiFiObs => _powerStateDidChangeForWiFi; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ScanCacheUpdatedForWiFiObs => _scanCacheUpdatedForWiFi; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SsidDidChangeForWiFiObs => _ssidDidChangeForWiFi; + /// + public override void BssidDidChangeForWiFi(string interfaceName) => _bssidDidChangeForWiFi.OnNext(interfaceName); + /// + public override void ClientConnectionInterrupted() => _clientConnectionInterrupted.OnNext(global::System.Reactive.Unit.Default); + /// + public override void ClientConnectionInvalidated() => _clientConnectionInvalidated.OnNext(global::System.Reactive.Unit.Default); + /// + public override void CountryCodeDidChangeForWiFi(string interfaceName) => _countryCodeDidChangeForWiFi.OnNext(interfaceName); + /// + public override void LinkDidChangeForWiFi(string interfaceName) => _linkDidChangeForWiFi.OnNext(interfaceName); + /// + public override void LinkQualityDidChangeForWiFi(string interfaceName, int rssi, double transmitRate) => _linkQualityDidChangeForWiFi.OnNext((interfaceName, rssi, transmitRate)); + /// + public override void ModeDidChangeForWiFi(string interfaceName) => _modeDidChangeForWiFi.OnNext(interfaceName); + /// + public override void PowerStateDidChangeForWiFi(string interfaceName) => _powerStateDidChangeForWiFi.OnNext(interfaceName); + /// + public override void ScanCacheUpdatedForWiFi(string interfaceName) => _scanCacheUpdatedForWiFi.OnNext(interfaceName); + /// + public override void SsidDidChangeForWiFi(string interfaceName) => _ssidDidChangeForWiFi.OnNext(interfaceName); + } +} + +namespace ExternalAccessory +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class EAAccessoryDelegateRx : global::ExternalAccessory.EAAccessoryDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _disconnected = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DisconnectedObs => _disconnected; + /// + public override void Disconnected(global::ExternalAccessory.EAAccessory accessory) => _disconnected.OnNext(accessory); + } +} + +namespace Foundation +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSCacheDelegateRx : global::Foundation.NSCacheDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSCache cache, global::Foundation.NSObject obj)> _willEvictObject = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSCache cache, global::Foundation.NSObject obj)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSCache cache, global::Foundation.NSObject obj)> WillEvictObjectObs => _willEvictObject; + /// + public override void WillEvictObject(global::Foundation.NSCache cache, global::Foundation.NSObject obj) => _willEvictObject.OnNext((cache, obj)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSKeyedArchiverDelegateRx : global::Foundation.NSKeyedArchiverDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject obj)> _encodedObject = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject obj)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _finished = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _finishing = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)> _replacingObject = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject obj)> EncodedObjectObs => _encodedObject; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedObs => _finished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishingObs => _finishing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)> ReplacingObjectObs => _replacingObject; + /// + public override void EncodedObject(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject obj) => _encodedObject.OnNext((archiver, obj)); + /// + public override void Finished(global::Foundation.NSKeyedArchiver archiver) => _finished.OnNext(archiver); + /// + public override void Finishing(global::Foundation.NSKeyedArchiver archiver) => _finishing.OnNext(archiver); + /// + public override void ReplacingObject(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject) => _replacingObject.OnNext((archiver, oldObject, newObject)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSKeyedUnarchiverDelegateRx : global::Foundation.NSKeyedUnarchiverDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _finished = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _finishing = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedUnarchiver unarchiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)> _replacingObject = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedUnarchiver unarchiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedObs => _finished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishingObs => _finishing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSKeyedUnarchiver unarchiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)> ReplacingObjectObs => _replacingObject; + /// + public override void Finished(global::Foundation.NSKeyedUnarchiver unarchiver) => _finished.OnNext(unarchiver); + /// + public override void Finishing(global::Foundation.NSKeyedUnarchiver unarchiver) => _finishing.OnNext(unarchiver); + /// + public override void ReplacingObject(global::Foundation.NSKeyedUnarchiver unarchiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject) => _replacingObject.OnNext((unarchiver, oldObject, newObject)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSMachPortDelegateRx : global::Foundation.NSMachPortDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _machMessageReceived = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable MachMessageReceivedObs => _machMessageReceived; + /// + public override void MachMessageReceived(global::System.IntPtr msgHeader) => _machMessageReceived.OnNext(msgHeader); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSNetServiceBrowserDelegateRx : global::Foundation.NSNetServiceBrowserDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing)> _domainRemoved = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing)> _foundDomain = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing)> _foundService = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSDictionary errors)> _notSearched = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSDictionary errors)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _searchStarted = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _searchStopped = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing)> _serviceRemoved = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing)> DomainRemovedObs => _domainRemoved; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing)> FoundDomainObs => _foundDomain; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing)> FoundServiceObs => _foundService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSDictionary errors)> NotSearchedObs => _notSearched; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SearchStartedObs => _searchStarted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SearchStoppedObs => _searchStopped; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing)> ServiceRemovedObs => _serviceRemoved; + /// + public override void DomainRemoved(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing) => _domainRemoved.OnNext((sender, domain, moreComing)); + /// + public override void FoundDomain(global::Foundation.NSNetServiceBrowser sender, string domain, bool moreComing) => _foundDomain.OnNext((sender, domain, moreComing)); + /// + public override void FoundService(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing) => _foundService.OnNext((sender, service, moreComing)); + /// + public override void NotSearched(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSDictionary errors) => _notSearched.OnNext((sender, errors)); + /// + public override void SearchStarted(global::Foundation.NSNetServiceBrowser sender) => _searchStarted.OnNext(sender); + /// + public override void SearchStopped(global::Foundation.NSNetServiceBrowser sender) => _searchStopped.OnNext(sender); + /// + public override void ServiceRemoved(global::Foundation.NSNetServiceBrowser sender, global::Foundation.NSNetService service, bool moreComing) => _serviceRemoved.OnNext((sender, service, moreComing)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSNetServiceDelegateRx : global::Foundation.NSNetServiceDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _addressResolved = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> _didAcceptConnection = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _published = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors)> _publishFailure = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors)> _resolveFailure = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _stopped = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSData data)> _updatedTxtRecordData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSNetService sender, global::Foundation.NSData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willPublish = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willResolve = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable AddressResolvedObs => _addressResolved; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetService sender, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> DidAcceptConnectionObs => _didAcceptConnection; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PublishedObs => _published; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors)> PublishFailureObs => _publishFailure; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors)> ResolveFailureObs => _resolveFailure; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable StoppedObs => _stopped; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSNetService sender, global::Foundation.NSData data)> UpdatedTxtRecordDataObs => _updatedTxtRecordData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillPublishObs => _willPublish; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillResolveObs => _willResolve; + /// + public override void AddressResolved(global::Foundation.NSNetService sender) => _addressResolved.OnNext(sender); + /// + public override void DidAcceptConnection(global::Foundation.NSNetService sender, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream) => _didAcceptConnection.OnNext((sender, inputStream, outputStream)); + /// + public override void Published(global::Foundation.NSNetService sender) => _published.OnNext(sender); + /// + public override void PublishFailure(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors) => _publishFailure.OnNext((sender, errors)); + /// + public override void ResolveFailure(global::Foundation.NSNetService sender, global::Foundation.NSDictionary errors) => _resolveFailure.OnNext((sender, errors)); + /// + public override void Stopped(global::Foundation.NSNetService sender) => _stopped.OnNext(sender); + /// + public override void UpdatedTxtRecordData(global::Foundation.NSNetService sender, global::Foundation.NSData data) => _updatedTxtRecordData.OnNext((sender, data)); + /// + public override void WillPublish(global::Foundation.NSNetService sender) => _willPublish.OnNext(sender); + /// + public override void WillResolve(global::Foundation.NSNetService sender) => _willResolve.OnNext(sender); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSPortDelegateRx : global::Foundation.NSPortDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _messageReceived = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable MessageReceivedObs => _messageReceived; + /// + public override void MessageReceived(global::Foundation.NSPortMessage message) => _messageReceived.OnNext(message); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSStreamDelegateRx : global::Foundation.NSStreamDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSStream theStream, global::Foundation.NSStreamEvent streamEvent)> _handleEvent = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSStream theStream, global::Foundation.NSStreamEvent streamEvent)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSStream theStream, global::Foundation.NSStreamEvent streamEvent)> HandleEventObs => _handleEvent; + /// + public override void HandleEvent(global::Foundation.NSStream theStream, global::Foundation.NSStreamEvent streamEvent) => _handleEvent.OnNext((theStream, streamEvent)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlConnectionDataDelegateRx : global::Foundation.NSUrlConnectionDataDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _finishedLoading = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSData data)> _receivedData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlResponse response)> _receivedResponse = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlResponse response)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::System.nint bytesWritten, global::System.nint totalBytesWritten, global::System.nint totalBytesExpectedToWrite)> _sentBodyData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::System.nint bytesWritten, global::System.nint totalBytesWritten, global::System.nint totalBytesExpectedToWrite)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedLoadingObs => _finishedLoading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSData data)> ReceivedDataObs => _receivedData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlResponse response)> ReceivedResponseObs => _receivedResponse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::System.nint bytesWritten, global::System.nint totalBytesWritten, global::System.nint totalBytesExpectedToWrite)> SentBodyDataObs => _sentBodyData; + /// + public override void FinishedLoading(global::Foundation.NSUrlConnection connection) => _finishedLoading.OnNext(connection); + /// + public override void ReceivedData(global::Foundation.NSUrlConnection connection, global::Foundation.NSData data) => _receivedData.OnNext((connection, data)); + /// + public override void ReceivedResponse(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlResponse response) => _receivedResponse.OnNext((connection, response)); + /// + public override void SentBodyData(global::Foundation.NSUrlConnection connection, global::System.nint bytesWritten, global::System.nint totalBytesWritten, global::System.nint totalBytesExpectedToWrite) => _sentBodyData.OnNext((connection, bytesWritten, totalBytesWritten, totalBytesExpectedToWrite)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlConnectionDelegateRx : global::Foundation.NSUrlConnectionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> _canceledAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSError error)> _failedWithError = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> _receivedAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> _willSendRequestForAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> CanceledAuthenticationChallengeObs => _canceledAuthenticationChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSError error)> FailedWithErrorObs => _failedWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> ReceivedAuthenticationChallengeObs => _receivedAuthenticationChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> WillSendRequestForAuthenticationChallengeObs => _willSendRequestForAuthenticationChallenge; + /// + public override void CanceledAuthenticationChallenge(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge) => _canceledAuthenticationChallenge.OnNext((connection, challenge)); + /// + public override void FailedWithError(global::Foundation.NSUrlConnection connection, global::Foundation.NSError error) => _failedWithError.OnNext((connection, error)); + /// + public override void ReceivedAuthenticationChallenge(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge) => _receivedAuthenticationChallenge.OnNext((connection, challenge)); + /// + public override void WillSendRequestForAuthenticationChallenge(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge) => _willSendRequestForAuthenticationChallenge.OnNext((connection, challenge)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NSUrlConnectionDownloadDelegateRx : global::Foundation.NSUrlConnectionDownloadDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrl destinationUrl)> _finishedDownloading = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrl destinationUrl)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, long totalBytesWritten, long expectedTotalBytes)> _resumedDownloading = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, long totalBytesWritten, long expectedTotalBytes)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, long bytesWritten, long totalBytesWritten, long expectedTotalBytes)> _wroteData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, long bytesWritten, long totalBytesWritten, long expectedTotalBytes)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrl destinationUrl)> FinishedDownloadingObs => _finishedDownloading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, long totalBytesWritten, long expectedTotalBytes)> ResumedDownloadingObs => _resumedDownloading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, long bytesWritten, long totalBytesWritten, long expectedTotalBytes)> WroteDataObs => _wroteData; + /// + public override void FinishedDownloading(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrl destinationUrl) => _finishedDownloading.OnNext((connection, destinationUrl)); + /// + public override void ResumedDownloading(global::Foundation.NSUrlConnection connection, long totalBytesWritten, long expectedTotalBytes) => _resumedDownloading.OnNext((connection, totalBytesWritten, expectedTotalBytes)); + /// + public override void WroteData(global::Foundation.NSUrlConnection connection, long bytesWritten, long totalBytesWritten, long expectedTotalBytes) => _wroteData.OnNext((connection, bytesWritten, totalBytesWritten, expectedTotalBytes)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlDownloadDelegateRx : global::Foundation.NSUrlDownloadDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlAuthenticationChallenge challenge)> _canceledAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlAuthenticationChallenge challenge)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, string path)> _createdDestination = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, string path)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, string suggestedFilename)> _decideDestination = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, string suggestedFilename)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _downloadBegan = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, global::Foundation.NSError error)> _failedWithError = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _finished = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlAuthenticationChallenge challenge)> _receivedAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlAuthenticationChallenge challenge)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, global::System.nuint length)> _receivedData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, global::System.nuint length)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlResponse response)> _receivedResponse = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlResponse response)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlResponse response, long startingByte)> _resume = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlResponse response, long startingByte)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlAuthenticationChallenge challenge)> CanceledAuthenticationChallengeObs => _canceledAuthenticationChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlDownload download, string path)> CreatedDestinationObs => _createdDestination; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlDownload download, string suggestedFilename)> DecideDestinationObs => _decideDestination; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DownloadBeganObs => _downloadBegan; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlDownload download, global::Foundation.NSError error)> FailedWithErrorObs => _failedWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedObs => _finished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlAuthenticationChallenge challenge)> ReceivedAuthenticationChallengeObs => _receivedAuthenticationChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlDownload download, global::System.nuint length)> ReceivedDataObs => _receivedData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlResponse response)> ReceivedResponseObs => _receivedResponse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlResponse response, long startingByte)> ResumeObs => _resume; + /// + public override void CanceledAuthenticationChallenge(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlAuthenticationChallenge challenge) => _canceledAuthenticationChallenge.OnNext((download, challenge)); + /// + public override void CreatedDestination(global::Foundation.NSUrlDownload download, string path) => _createdDestination.OnNext((download, path)); + /// + public override void DecideDestination(global::Foundation.NSUrlDownload download, string suggestedFilename) => _decideDestination.OnNext((download, suggestedFilename)); + /// + public override void DownloadBegan(global::Foundation.NSUrlDownload download) => _downloadBegan.OnNext(download); + /// + public override void FailedWithError(global::Foundation.NSUrlDownload download, global::Foundation.NSError error) => _failedWithError.OnNext((download, error)); + /// + public override void Finished(global::Foundation.NSUrlDownload download) => _finished.OnNext(download); + /// + public override void ReceivedAuthenticationChallenge(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlAuthenticationChallenge challenge) => _receivedAuthenticationChallenge.OnNext((download, challenge)); + /// + public override void ReceivedData(global::Foundation.NSUrlDownload download, global::System.nuint length) => _receivedData.OnNext((download, length)); + /// + public override void ReceivedResponse(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlResponse response) => _receivedResponse.OnNext((download, response)); + /// + public override void Resume(global::Foundation.NSUrlDownload download, global::Foundation.NSUrlResponse response, long startingByte) => _resume.OnNext((download, response, startingByte)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlSessionDataDelegateRx : global::Foundation.NSUrlSessionDataDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionDownloadTask downloadTask)> _didBecomeDownloadTask = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionDownloadTask downloadTask)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionStreamTask streamTask)> _didBecomeStreamTask = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionStreamTask streamTask)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSData data)> _didReceiveData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlResponse response, global::System.Action completionHandler)> _didReceiveResponse = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlResponse response, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSCachedUrlResponse proposedResponse, global::System.Action completionHandler)> _willCacheResponse = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSCachedUrlResponse proposedResponse, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionDownloadTask downloadTask)> DidBecomeDownloadTaskObs => _didBecomeDownloadTask; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionStreamTask streamTask)> DidBecomeStreamTaskObs => _didBecomeStreamTask; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSData data)> DidReceiveDataObs => _didReceiveData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlResponse response, global::System.Action completionHandler)> DidReceiveResponseObs => _didReceiveResponse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSCachedUrlResponse proposedResponse, global::System.Action completionHandler)> WillCacheResponseObs => _willCacheResponse; + /// + public override void DidBecomeDownloadTask(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionDownloadTask downloadTask) => _didBecomeDownloadTask.OnNext((session, dataTask, downloadTask)); + /// + public override void DidBecomeStreamTask(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionStreamTask streamTask) => _didBecomeStreamTask.OnNext((session, dataTask, streamTask)); + /// + public override void DidReceiveData(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSData data) => _didReceiveData.OnNext((session, dataTask, data)); + /// + public override void DidReceiveResponse(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlResponse response, global::System.Action completionHandler) => _didReceiveResponse.OnNext((session, dataTask, response, completionHandler)); + /// + public override void WillCacheResponse(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSCachedUrlResponse proposedResponse, global::System.Action completionHandler) => _willCacheResponse.OnNext((session, dataTask, proposedResponse, completionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlSessionDelegateRx : global::Foundation.NSUrlSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSError error)> _didBecomeInvalid = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinishEventsForBackgroundSession = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> _didReceiveChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSError error)> DidBecomeInvalidObs => _didBecomeInvalid; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishEventsForBackgroundSessionObs => _didFinishEventsForBackgroundSession; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> DidReceiveChallengeObs => _didReceiveChallenge; + /// + public override void DidBecomeInvalid(global::Foundation.NSUrlSession session, global::Foundation.NSError error) => _didBecomeInvalid.OnNext((session, error)); + /// + public override void DidFinishEventsForBackgroundSession(global::Foundation.NSUrlSession session) => _didFinishEventsForBackgroundSession.OnNext(session); + /// + public override void DidReceiveChallenge(global::Foundation.NSUrlSession session, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler) => _didReceiveChallenge.OnNext((session, challenge, completionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NSUrlSessionDownloadDelegateRx : global::Foundation.NSUrlSessionDownloadDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, global::Foundation.NSUrl location)> _didFinishDownloading = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, global::Foundation.NSUrl location)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long resumeFileOffset, long expectedTotalBytes)> _didResume = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long resumeFileOffset, long expectedTotalBytes)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long bytesWritten, long totalBytesWritten, long totalBytesExpectedToWrite)> _didWriteData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long bytesWritten, long totalBytesWritten, long totalBytesExpectedToWrite)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, global::Foundation.NSUrl location)> DidFinishDownloadingObs => _didFinishDownloading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long resumeFileOffset, long expectedTotalBytes)> DidResumeObs => _didResume; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long bytesWritten, long totalBytesWritten, long totalBytesExpectedToWrite)> DidWriteDataObs => _didWriteData; + /// + public override void DidFinishDownloading(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, global::Foundation.NSUrl location) => _didFinishDownloading.OnNext((session, downloadTask, location)); + /// + public override void DidResume(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long resumeFileOffset, long expectedTotalBytes) => _didResume.OnNext((session, downloadTask, resumeFileOffset, expectedTotalBytes)); + /// + public override void DidWriteData(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long bytesWritten, long totalBytesWritten, long totalBytesExpectedToWrite) => _didWriteData.OnNext((session, downloadTask, bytesWritten, totalBytesWritten, totalBytesExpectedToWrite)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlSessionStreamDelegateRx : global::Foundation.NSUrlSessionStreamDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> _betterRouteDiscovered = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> _completedTaskCaptureStreams = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> _readClosed = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> _writeClosed = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> BetterRouteDiscoveredObs => _betterRouteDiscovered; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> CompletedTaskCaptureStreamsObs => _completedTaskCaptureStreams; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> ReadClosedObs => _readClosed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> WriteClosedObs => _writeClosed; + /// + public override void BetterRouteDiscovered(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask) => _betterRouteDiscovered.OnNext((session, streamTask)); + /// + public override void CompletedTaskCaptureStreams(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream) => _completedTaskCaptureStreams.OnNext((session, streamTask, inputStream, outputStream)); + /// + public override void ReadClosed(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask) => _readClosed.OnNext((session, streamTask)); + /// + public override void WriteClosed(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask) => _writeClosed.OnNext((session, streamTask)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlSessionTaskDelegateRx : global::Foundation.NSUrlSessionTaskDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error)> _didCompleteWithError = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics)> _didFinishCollectingMetrics = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> _didReceiveChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend)> _didSendBodyData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler)> _needNewBodyStream = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task)> _taskIsWaitingForConnectivity = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler)> _willBeginDelayedRequest = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler)> _willPerformHttpRedirection = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error)> DidCompleteWithErrorObs => _didCompleteWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics)> DidFinishCollectingMetricsObs => _didFinishCollectingMetrics; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> DidReceiveChallengeObs => _didReceiveChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend)> DidSendBodyDataObs => _didSendBodyData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler)> NeedNewBodyStreamObs => _needNewBodyStream; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task)> TaskIsWaitingForConnectivityObs => _taskIsWaitingForConnectivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler)> WillBeginDelayedRequestObs => _willBeginDelayedRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler)> WillPerformHttpRedirectionObs => _willPerformHttpRedirection; + /// + public override void DidCompleteWithError(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error) => _didCompleteWithError.OnNext((session, task, error)); + /// + public override void DidFinishCollectingMetrics(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics) => _didFinishCollectingMetrics.OnNext((session, task, metrics)); + /// + public override void DidReceiveChallenge(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler) => _didReceiveChallenge.OnNext((session, task, challenge, completionHandler)); + /// + public override void DidSendBodyData(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend) => _didSendBodyData.OnNext((session, task, bytesSent, totalBytesSent, totalBytesExpectedToSend)); + /// + public override void NeedNewBodyStream(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler) => _needNewBodyStream.OnNext((session, task, completionHandler)); + /// + public override void TaskIsWaitingForConnectivity(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task) => _taskIsWaitingForConnectivity.OnNext((session, task)); + /// + public override void WillBeginDelayedRequest(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler) => _willBeginDelayedRequest.OnNext((session, task, request, completionHandler)); + /// + public override void WillPerformHttpRedirection(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler) => _willPerformHttpRedirection.OnNext((session, task, response, newRequest, completionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlSessionWebSocketDelegateRx : global::Foundation.NSUrlSessionWebSocketDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, global::Foundation.NSUrlSessionWebSocketCloseCode closeCode, global::Foundation.NSData reason)> _didClose = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, global::Foundation.NSUrlSessionWebSocketCloseCode closeCode, global::Foundation.NSData reason)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, string protocol)> _didOpen = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, string protocol)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, global::Foundation.NSUrlSessionWebSocketCloseCode closeCode, global::Foundation.NSData reason)> DidCloseObs => _didClose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, string protocol)> DidOpenObs => _didOpen; + /// + public override void DidClose(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, global::Foundation.NSUrlSessionWebSocketCloseCode closeCode, global::Foundation.NSData reason) => _didClose.OnNext((session, webSocketTask, closeCode, reason)); + /// + public override void DidOpen(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, string protocol) => _didOpen.OnNext((session, webSocketTask, protocol)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUserActivityDelegateRx : global::Foundation.NSUserActivityDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUserActivity userActivity, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> _userActivityReceivedData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUserActivity userActivity, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _userActivityWasContinued = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _userActivityWillSave = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUserActivity userActivity, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> UserActivityReceivedDataObs => _userActivityReceivedData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UserActivityWasContinuedObs => _userActivityWasContinued; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UserActivityWillSaveObs => _userActivityWillSave; + /// + public override void UserActivityReceivedData(global::Foundation.NSUserActivity userActivity, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream) => _userActivityReceivedData.OnNext((userActivity, inputStream, outputStream)); + /// + public override void UserActivityWasContinued(global::Foundation.NSUserActivity userActivity) => _userActivityWasContinued.OnNext(userActivity); + /// + public override void UserActivityWillSave(global::Foundation.NSUserActivity userActivity) => _userActivityWillSave.OnNext(userActivity); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUserNotificationCenterDelegateRx : global::Foundation.NSUserNotificationCenterDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUserNotificationCenter center, global::Foundation.NSUserNotification notification)> _didActivateNotification = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUserNotificationCenter center, global::Foundation.NSUserNotification notification)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUserNotificationCenter center, global::Foundation.NSUserNotification notification)> _didDeliverNotification = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUserNotificationCenter center, global::Foundation.NSUserNotification notification)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUserNotificationCenter center, global::Foundation.NSUserNotification notification)> DidActivateNotificationObs => _didActivateNotification; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUserNotificationCenter center, global::Foundation.NSUserNotification notification)> DidDeliverNotificationObs => _didDeliverNotification; + /// + public override void DidActivateNotification(global::Foundation.NSUserNotificationCenter center, global::Foundation.NSUserNotification notification) => _didActivateNotification.OnNext((center, notification)); + /// + public override void DidDeliverNotification(global::Foundation.NSUserNotificationCenter center, global::Foundation.NSUserNotification notification) => _didDeliverNotification.OnNext((center, notification)); + } +} + +namespace GameKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKAchievementViewControllerDelegateRx : global::GameKit.GKAchievementViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didFinish = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishObs => _didFinish; + /// + public override void DidFinish(global::GameKit.GKAchievementViewController viewController) => _didFinish.OnNext(viewController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class GKChallengeEventHandlerDelegateRx : global::GameKit.GKChallengeEventHandlerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _localPlayerCompletedChallenge = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _localPlayerReceivedChallenge = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _localPlayerSelectedChallenge = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _remotePlayerCompletedChallenge = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LocalPlayerCompletedChallengeObs => _localPlayerCompletedChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LocalPlayerReceivedChallengeObs => _localPlayerReceivedChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable LocalPlayerSelectedChallengeObs => _localPlayerSelectedChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable RemotePlayerCompletedChallengeObs => _remotePlayerCompletedChallenge; + /// + public override void LocalPlayerCompletedChallenge(global::GameKit.GKChallenge challenge) => _localPlayerCompletedChallenge.OnNext(challenge); + /// + public override void LocalPlayerReceivedChallenge(global::GameKit.GKChallenge challenge) => _localPlayerReceivedChallenge.OnNext(challenge); + /// + public override void LocalPlayerSelectedChallenge(global::GameKit.GKChallenge challenge) => _localPlayerSelectedChallenge.OnNext(challenge); + /// + public override void RemotePlayerCompletedChallenge(global::GameKit.GKChallenge challenge) => _remotePlayerCompletedChallenge.OnNext(challenge); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKChallengesViewControllerDelegateRx : global::GameKit.GKChallengesViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didFinish = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishObs => _didFinish; + /// + public override void DidFinish(global::GameKit.GKChallengesViewController viewController) => _didFinish.OnNext(viewController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKFriendRequestComposeViewControllerDelegateRx : global::GameKit.GKFriendRequestComposeViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didFinish = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishObs => _didFinish; + /// + public override void DidFinish(global::GameKit.GKFriendRequestComposeViewController viewController) => _didFinish.OnNext(viewController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKGameCenterControllerDelegateRx : global::GameKit.GKGameCenterControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _finished = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedObs => _finished; + /// + public override void Finished(global::GameKit.GKGameCenterViewController controller) => _finished.OnNext(controller); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKLeaderboardViewControllerDelegateRx : global::GameKit.GKLeaderboardViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didFinish = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishObs => _didFinish; + /// + public override void DidFinish(global::GameKit.GKLeaderboardViewController viewController) => _didFinish.OnNext(viewController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class GKMatchDelegateRx : global::GameKit.GKMatchDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, string playerId, global::Foundation.NSError error)> _connectionFailed = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, string playerId, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSData data, string playerId)> _dataReceived = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSData data, string playerId)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer recipient, global::GameKit.GKPlayer player)> _dataReceivedForRecipient = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer recipient, global::GameKit.GKPlayer player)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer player)> _dataReceivedFromPlayer = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer player)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSError error)> _failed = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, string playerId, global::GameKit.GKPlayerConnectionState state)> _stateChanged = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, string playerId, global::GameKit.GKPlayerConnectionState state)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::GameKit.GKPlayer player, global::GameKit.GKPlayerConnectionState state)> _stateChangedForPlayer = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatch match, global::GameKit.GKPlayer player, global::GameKit.GKPlayerConnectionState state)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + [global::System.ObsoleteAttribute("It will never be called.", false)] + public global::System.IObservable<(global::GameKit.GKMatch match, string playerId, global::Foundation.NSError error)> ConnectionFailedObs => _connectionFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatch match, global::Foundation.NSData data, string playerId)> DataReceivedObs => _dataReceived; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer recipient, global::GameKit.GKPlayer player)> DataReceivedForRecipientObs => _dataReceivedForRecipient; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer player)> DataReceivedFromPlayerObs => _dataReceivedFromPlayer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatch match, global::Foundation.NSError error)> FailedObs => _failed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatch match, string playerId, global::GameKit.GKPlayerConnectionState state)> StateChangedObs => _stateChanged; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatch match, global::GameKit.GKPlayer player, global::GameKit.GKPlayerConnectionState state)> StateChangedForPlayerObs => _stateChangedForPlayer; + /// + [global::System.ObsoleteAttribute("It will never be called.", false)] + public override void ConnectionFailed(global::GameKit.GKMatch match, string playerId, global::Foundation.NSError error) => _connectionFailed.OnNext((match, playerId, error)); + /// + public override void DataReceived(global::GameKit.GKMatch match, global::Foundation.NSData data, string playerId) => _dataReceived.OnNext((match, data, playerId)); + /// + public override void DataReceivedForRecipient(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer recipient, global::GameKit.GKPlayer player) => _dataReceivedForRecipient.OnNext((match, data, recipient, player)); + /// + public override void DataReceivedFromPlayer(global::GameKit.GKMatch match, global::Foundation.NSData data, global::GameKit.GKPlayer player) => _dataReceivedFromPlayer.OnNext((match, data, player)); + /// + public override void Failed(global::GameKit.GKMatch match, global::Foundation.NSError error) => _failed.OnNext((match, error)); + /// + public override void StateChanged(global::GameKit.GKMatch match, string playerId, global::GameKit.GKPlayerConnectionState state) => _stateChanged.OnNext((match, playerId, state)); + /// + public override void StateChangedForPlayer(global::GameKit.GKMatch match, global::GameKit.GKPlayer player, global::GameKit.GKPlayerConnectionState state) => _stateChangedForPlayer.OnNext((match, player, state)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKMatchmakerViewControllerDelegateRx : global::GameKit.GKMatchmakerViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::Foundation.NSError error)> _didFailWithError = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer[] playerIDs)> _didFindHostedPlayers = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer[] playerIDs)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKMatch match)> _didFindMatch = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKMatch match)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::System.String[] playerIDs)> _didFindPlayers = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::System.String[] playerIDs)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer playerID)> _hostedPlayerDidAccept = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer playerID)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, string playerID)> _receivedAcceptFromHostedPlayer = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKMatchmakerViewController viewController, string playerID)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _wasCancelled = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatchmakerViewController viewController, global::Foundation.NSError error)> DidFailWithErrorObs => _didFailWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer[] playerIDs)> DidFindHostedPlayersObs => _didFindHostedPlayers; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKMatch match)> DidFindMatchObs => _didFindMatch; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatchmakerViewController viewController, global::System.String[] playerIDs)> DidFindPlayersObs => _didFindPlayers; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer playerID)> HostedPlayerDidAcceptObs => _hostedPlayerDidAccept; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKMatchmakerViewController viewController, string playerID)> ReceivedAcceptFromHostedPlayerObs => _receivedAcceptFromHostedPlayer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WasCancelledObs => _wasCancelled; + /// + public override void DidFailWithError(global::GameKit.GKMatchmakerViewController viewController, global::Foundation.NSError error) => _didFailWithError.OnNext((viewController, error)); + /// + public override void DidFindHostedPlayers(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer[] playerIDs) => _didFindHostedPlayers.OnNext((viewController, playerIDs)); + /// + public override void DidFindMatch(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKMatch match) => _didFindMatch.OnNext((viewController, match)); + /// + public override void DidFindPlayers(global::GameKit.GKMatchmakerViewController viewController, global::System.String[] playerIDs) => _didFindPlayers.OnNext((viewController, playerIDs)); + /// + public override void HostedPlayerDidAccept(global::GameKit.GKMatchmakerViewController viewController, global::GameKit.GKPlayer playerID) => _hostedPlayerDidAccept.OnNext((viewController, playerID)); + /// + public override void ReceivedAcceptFromHostedPlayer(global::GameKit.GKMatchmakerViewController viewController, string playerID) => _receivedAcceptFromHostedPlayer.OnNext((viewController, playerID)); + /// + public override void WasCancelled(global::GameKit.GKMatchmakerViewController viewController) => _wasCancelled.OnNext(viewController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class GKSessionDelegateRx : global::GameKit.GKSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, global::Foundation.NSError error)> _failedWithError = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, string peerID, global::GameKit.GKPeerConnectionState state)> _peerChangedState = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, string peerID, global::GameKit.GKPeerConnectionState state)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, string peerID, global::Foundation.NSError error)> _peerConnectionFailed = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, string peerID, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, string peerID)> _peerConnectionRequest = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKSession session, string peerID)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKSession session, global::Foundation.NSError error)> FailedWithErrorObs => _failedWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKSession session, string peerID, global::GameKit.GKPeerConnectionState state)> PeerChangedStateObs => _peerChangedState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKSession session, string peerID, global::Foundation.NSError error)> PeerConnectionFailedObs => _peerConnectionFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKSession session, string peerID)> PeerConnectionRequestObs => _peerConnectionRequest; + /// + public override void FailedWithError(global::GameKit.GKSession session, global::Foundation.NSError error) => _failedWithError.OnNext((session, error)); + /// + public override void PeerChangedState(global::GameKit.GKSession session, string peerID, global::GameKit.GKPeerConnectionState state) => _peerChangedState.OnNext((session, peerID, state)); + /// + public override void PeerConnectionFailed(global::GameKit.GKSession session, string peerID, global::Foundation.NSError error) => _peerConnectionFailed.OnNext((session, peerID, error)); + /// + public override void PeerConnectionRequest(global::GameKit.GKSession session, string peerID) => _peerConnectionRequest.OnNext((session, peerID)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKTurnBasedEventHandlerDelegateRx : global::GameKit.GKTurnBasedEventHandlerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _handleInviteFromGameCenter = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _handleMatchEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatch match, bool activated)> _handleTurnEvent = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatch match, bool activated)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _handleTurnEventForMatch = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable HandleInviteFromGameCenterObs => _handleInviteFromGameCenter; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable HandleMatchEndedObs => _handleMatchEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKTurnBasedMatch match, bool activated)> HandleTurnEventObs => _handleTurnEvent; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable HandleTurnEventForMatchObs => _handleTurnEventForMatch; + /// + public override void HandleInviteFromGameCenter(global::Foundation.NSString[] playersToInvite) => _handleInviteFromGameCenter.OnNext(playersToInvite); + /// + public override void HandleMatchEnded(global::GameKit.GKTurnBasedMatch match) => _handleMatchEnded.OnNext(match); + /// + public override void HandleTurnEvent(global::GameKit.GKTurnBasedMatch match, bool activated) => _handleTurnEvent.OnNext((match, activated)); + /// + public override void HandleTurnEventForMatch(global::GameKit.GKTurnBasedMatch match) => _handleTurnEventForMatch.OnNext(match); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKTurnBasedMatchmakerViewControllerDelegateRx : global::GameKit.GKTurnBasedMatchmakerViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::Foundation.NSError error)> _failedWithError = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match)> _foundMatch = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match)> _playerQuitForMatch = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _wasCancelled = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::Foundation.NSError error)> FailedWithErrorObs => _failedWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match)> FoundMatchObs => _foundMatch; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match)> PlayerQuitForMatchObs => _playerQuitForMatch; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WasCancelledObs => _wasCancelled; + /// + public override void FailedWithError(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::Foundation.NSError error) => _failedWithError.OnNext((viewController, error)); + /// + public override void FoundMatch(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match) => _foundMatch.OnNext((viewController, match)); + /// + public override void PlayerQuitForMatch(global::GameKit.GKTurnBasedMatchmakerViewController viewController, global::GameKit.GKTurnBasedMatch match) => _playerQuitForMatch.OnNext((viewController, match)); + /// + public override void WasCancelled(global::GameKit.GKTurnBasedMatchmakerViewController viewController) => _wasCancelled.OnNext(viewController); + } +} + +namespace GameplayKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class GKAgentDelegateRx : global::GameplayKit.GKAgentDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _agentDidUpdate = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _agentWillUpdate = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable AgentDidUpdateObs => _agentDidUpdate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable AgentWillUpdateObs => _agentWillUpdate; + /// + public override void AgentDidUpdate(global::GameplayKit.GKAgent agent) => _agentDidUpdate.OnNext(agent); + /// + public override void AgentWillUpdate(global::GameplayKit.GKAgent agent) => _agentWillUpdate.OnNext(agent); + } +} + +namespace ImageCaptureCore +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class ICCameraDeviceDelegateRx : global::ImageCaptureCore.ICCameraDeviceDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem item)> _didAddItem = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem item)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem[] items)> _didAddItems = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem[] items)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeReady = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeReadyWithCompleteContentCatalog = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeCapability = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeName = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeSharingState = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> _didCloseSession = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice scanner, global::Foundation.NSError error)> _didCompleteDeleteFiles = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice scanner, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> _didEncounterError = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> _didOpenSession = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSString buttonType)> _didReceiveButtonPress = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSString buttonType)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary notification, global::Foundation.NSData data)> _didReceiveCustomNotification = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary notification, global::Foundation.NSData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem forItem)> _didReceiveMetadata = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem forItem)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::Foundation.NSData eventData)> _didReceivePtpEvent = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::Foundation.NSData eventData)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary status)> _didReceiveStatusInformation = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary status)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem forItem)> _didReceiveThumbnail = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem forItem)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didRemoveDevice = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem item)> _didRemoveItem = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem item)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem[] items)> _didRemoveItems = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem[] items)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem[] items)> _didRenameItems = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem[] items)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem item)> DidAddItemObs => _didAddItem; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem[] items)> DidAddItemsObs => _didAddItems; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeReadyObs => _didBecomeReady; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeReadyWithCompleteContentCatalogObs => _didBecomeReadyWithCompleteContentCatalog; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeCapabilityObs => _didChangeCapability; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeNameObs => _didChangeName; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeSharingStateObs => _didChangeSharingState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> DidCloseSessionObs => _didCloseSession; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICCameraDevice scanner, global::Foundation.NSError error)> DidCompleteDeleteFilesObs => _didCompleteDeleteFiles; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> DidEncounterErrorObs => _didEncounterError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> DidOpenSessionObs => _didOpenSession; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSString buttonType)> DidReceiveButtonPressObs => _didReceiveButtonPress; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary notification, global::Foundation.NSData data)> DidReceiveCustomNotificationObs => _didReceiveCustomNotification; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem forItem)> DidReceiveMetadataObs => _didReceiveMetadata; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICCameraDevice camera, global::Foundation.NSData eventData)> DidReceivePtpEventObs => _didReceivePtpEvent; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary status)> DidReceiveStatusInformationObs => _didReceiveStatusInformation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem forItem)> DidReceiveThumbnailObs => _didReceiveThumbnail; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidRemoveDeviceObs => _didRemoveDevice; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem item)> DidRemoveItemObs => _didRemoveItem; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem[] items)> DidRemoveItemsObs => _didRemoveItems; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem[] items)> DidRenameItemsObs => _didRenameItems; + /// + public override void DidAddItem(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem item) => _didAddItem.OnNext((camera, item)); + /// + public override void DidAddItems(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem[] items) => _didAddItems.OnNext((camera, items)); + /// + public override void DidBecomeReady(global::ImageCaptureCore.ICDevice device) => _didBecomeReady.OnNext(device); + /// + public override void DidBecomeReadyWithCompleteContentCatalog(global::ImageCaptureCore.ICDevice device) => _didBecomeReadyWithCompleteContentCatalog.OnNext(device); + /// + public override void DidChangeCapability(global::ImageCaptureCore.ICCameraDevice camera) => _didChangeCapability.OnNext(camera); + /// + public override void DidChangeName(global::ImageCaptureCore.ICDevice device) => _didChangeName.OnNext(device); + /// + public override void DidChangeSharingState(global::ImageCaptureCore.ICDevice device) => _didChangeSharingState.OnNext(device); + /// + public override void DidCloseSession(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error) => _didCloseSession.OnNext((device, error)); + /// + public override void DidCompleteDeleteFiles(global::ImageCaptureCore.ICCameraDevice scanner, global::Foundation.NSError error) => _didCompleteDeleteFiles.OnNext((scanner, error)); + /// + public override void DidEncounterError(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error) => _didEncounterError.OnNext((device, error)); + /// + public override void DidOpenSession(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error) => _didOpenSession.OnNext((device, error)); + /// + public override void DidReceiveButtonPress(global::ImageCaptureCore.ICDevice device, global::Foundation.NSString buttonType) => _didReceiveButtonPress.OnNext((device, buttonType)); + /// + public override void DidReceiveCustomNotification(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary notification, global::Foundation.NSData data) => _didReceiveCustomNotification.OnNext((device, notification, data)); + /// + public override void DidReceiveMetadata(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem forItem) => _didReceiveMetadata.OnNext((camera, forItem)); + /// + public override void DidReceivePtpEvent(global::ImageCaptureCore.ICCameraDevice camera, global::Foundation.NSData eventData) => _didReceivePtpEvent.OnNext((camera, eventData)); + /// + public override void DidReceiveStatusInformation(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary status) => _didReceiveStatusInformation.OnNext((device, status)); + /// + public override void DidReceiveThumbnail(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem forItem) => _didReceiveThumbnail.OnNext((camera, forItem)); + /// + public override void DidRemoveDevice(global::ImageCaptureCore.ICDevice device) => _didRemoveDevice.OnNext(device); + /// + public override void DidRemoveItem(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem item) => _didRemoveItem.OnNext((camera, item)); + /// + public override void DidRemoveItems(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem[] items) => _didRemoveItems.OnNext((camera, items)); + /// + public override void DidRenameItems(global::ImageCaptureCore.ICCameraDevice camera, global::ImageCaptureCore.ICCameraItem[] items) => _didRenameItems.OnNext((camera, items)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class ICCameraDeviceDownloadDelegateRx : global::ImageCaptureCore.ICCameraDeviceDownloadDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraFile file, global::Foundation.NSError error, global::Foundation.NSDictionary options, global::System.IntPtr contextInfo)> _didDownloadFile = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraFile file, global::Foundation.NSError error, global::Foundation.NSDictionary options, global::System.IntPtr contextInfo)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraFile file, long downloadedBytes, long maxBytes)> _didReceiveDownloadProgress = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICCameraFile file, long downloadedBytes, long maxBytes)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICCameraFile file, global::Foundation.NSError error, global::Foundation.NSDictionary options, global::System.IntPtr contextInfo)> DidDownloadFileObs => _didDownloadFile; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICCameraFile file, long downloadedBytes, long maxBytes)> DidReceiveDownloadProgressObs => _didReceiveDownloadProgress; + /// + public override void DidDownloadFile(global::ImageCaptureCore.ICCameraFile file, global::Foundation.NSError error, global::Foundation.NSDictionary options, global::System.IntPtr contextInfo) => _didDownloadFile.OnNext((file, error, options, contextInfo)); + /// + public override void DidReceiveDownloadProgress(global::ImageCaptureCore.ICCameraFile file, long downloadedBytes, long maxBytes) => _didReceiveDownloadProgress.OnNext((file, downloadedBytes, maxBytes)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class ICDeviceBrowserDelegateRx : global::ImageCaptureCore.ICDeviceBrowserDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device)> _deviceDidChangeName = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device)> _deviceDidChangeSharingState = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device, bool moreComing)> _didAddDevice = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device, bool moreComing)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEnumerateLocalDevices = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device, bool moreGoing)> _didRemoveDevice = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device, bool moreGoing)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device)> _requestsSelectDevice = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device)> DeviceDidChangeNameObs => _deviceDidChangeName; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device)> DeviceDidChangeSharingStateObs => _deviceDidChangeSharingState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device, bool moreComing)> DidAddDeviceObs => _didAddDevice; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEnumerateLocalDevicesObs => _didEnumerateLocalDevices; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device, bool moreGoing)> DidRemoveDeviceObs => _didRemoveDevice; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device)> RequestsSelectDeviceObs => _requestsSelectDevice; + /// + public override void DeviceDidChangeName(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device) => _deviceDidChangeName.OnNext((browser, device)); + /// + public override void DeviceDidChangeSharingState(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device) => _deviceDidChangeSharingState.OnNext((browser, device)); + /// + public override void DidAddDevice(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device, bool moreComing) => _didAddDevice.OnNext((browser, device, moreComing)); + /// + public override void DidEnumerateLocalDevices(global::ImageCaptureCore.ICDeviceBrowser browser) => _didEnumerateLocalDevices.OnNext(browser); + /// + public override void DidRemoveDevice(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device, bool moreGoing) => _didRemoveDevice.OnNext((browser, device, moreGoing)); + /// + public override void RequestsSelectDevice(global::ImageCaptureCore.ICDeviceBrowser browser, global::ImageCaptureCore.ICDevice device) => _requestsSelectDevice.OnNext((browser, device)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class ICDeviceDelegateRx : global::ImageCaptureCore.ICDeviceDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeReady = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeName = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeSharingState = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> _didCloseSession = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> _didEncounterError = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> _didOpenSession = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSString buttonType)> _didReceiveButtonPress = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSString buttonType)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary notification, global::Foundation.NSData data)> _didReceiveCustomNotification = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary notification, global::Foundation.NSData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary status)> _didReceiveStatusInformation = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary status)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didRemoveDevice = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeReadyObs => _didBecomeReady; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeNameObs => _didChangeName; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeSharingStateObs => _didChangeSharingState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> DidCloseSessionObs => _didCloseSession; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> DidEncounterErrorObs => _didEncounterError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> DidOpenSessionObs => _didOpenSession; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSString buttonType)> DidReceiveButtonPressObs => _didReceiveButtonPress; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary notification, global::Foundation.NSData data)> DidReceiveCustomNotificationObs => _didReceiveCustomNotification; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary status)> DidReceiveStatusInformationObs => _didReceiveStatusInformation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidRemoveDeviceObs => _didRemoveDevice; + /// + public override void DidBecomeReady(global::ImageCaptureCore.ICDevice device) => _didBecomeReady.OnNext(device); + /// + public override void DidChangeName(global::ImageCaptureCore.ICDevice device) => _didChangeName.OnNext(device); + /// + public override void DidChangeSharingState(global::ImageCaptureCore.ICDevice device) => _didChangeSharingState.OnNext(device); + /// + public override void DidCloseSession(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error) => _didCloseSession.OnNext((device, error)); + /// + public override void DidEncounterError(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error) => _didEncounterError.OnNext((device, error)); + /// + public override void DidOpenSession(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error) => _didOpenSession.OnNext((device, error)); + /// + public override void DidReceiveButtonPress(global::ImageCaptureCore.ICDevice device, global::Foundation.NSString buttonType) => _didReceiveButtonPress.OnNext((device, buttonType)); + /// + public override void DidReceiveCustomNotification(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary notification, global::Foundation.NSData data) => _didReceiveCustomNotification.OnNext((device, notification, data)); + /// + public override void DidReceiveStatusInformation(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary status) => _didReceiveStatusInformation.OnNext((device, status)); + /// + public override void DidRemoveDevice(global::ImageCaptureCore.ICDevice device) => _didRemoveDevice.OnNext(device); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class ICScannerDeviceDelegateRx : global::ImageCaptureCore.ICScannerDeviceDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeAvailable = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeReady = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeName = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeSharingState = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> _didCloseSession = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICScannerDevice scanner, global::Foundation.NSError error)> _didCompleteOverviewScan = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICScannerDevice scanner, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICScannerDevice scanner, global::Foundation.NSError error)> _didCompleteScan = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICScannerDevice scanner, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> _didEncounterError = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> _didOpenSession = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSString buttonType)> _didReceiveButtonPress = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSString buttonType)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary notification, global::Foundation.NSData data)> _didReceiveCustomNotification = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary notification, global::Foundation.NSData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary status)> _didReceiveStatusInformation = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary status)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didRemoveDevice = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICScannerDevice scanner, global::ImageCaptureCore.ICScannerBandData data)> _didScanToBandData = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICScannerDevice scanner, global::ImageCaptureCore.ICScannerBandData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICScannerDevice scanner, global::Foundation.NSUrl url, global::Foundation.NSData data)> _didScanToUrl = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICScannerDevice scanner, global::Foundation.NSUrl url, global::Foundation.NSData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICScannerDevice scanner, global::ImageCaptureCore.ICScannerFunctionalUnit functionalUnit, global::Foundation.NSError error)> _didSelectFunctionalUnit = new Pharmacist.Common.SingleAwaitSubject<(global::ImageCaptureCore.ICScannerDevice scanner, global::ImageCaptureCore.ICScannerFunctionalUnit functionalUnit, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeAvailableObs => _didBecomeAvailable; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeReadyObs => _didBecomeReady; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeNameObs => _didChangeName; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeSharingStateObs => _didChangeSharingState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> DidCloseSessionObs => _didCloseSession; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICScannerDevice scanner, global::Foundation.NSError error)> DidCompleteOverviewScanObs => _didCompleteOverviewScan; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICScannerDevice scanner, global::Foundation.NSError error)> DidCompleteScanObs => _didCompleteScan; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> DidEncounterErrorObs => _didEncounterError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error)> DidOpenSessionObs => _didOpenSession; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSString buttonType)> DidReceiveButtonPressObs => _didReceiveButtonPress; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary notification, global::Foundation.NSData data)> DidReceiveCustomNotificationObs => _didReceiveCustomNotification; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary status)> DidReceiveStatusInformationObs => _didReceiveStatusInformation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidRemoveDeviceObs => _didRemoveDevice; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICScannerDevice scanner, global::ImageCaptureCore.ICScannerBandData data)> DidScanToBandDataObs => _didScanToBandData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICScannerDevice scanner, global::Foundation.NSUrl url, global::Foundation.NSData data)> DidScanToUrlObs => _didScanToUrl; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageCaptureCore.ICScannerDevice scanner, global::ImageCaptureCore.ICScannerFunctionalUnit functionalUnit, global::Foundation.NSError error)> DidSelectFunctionalUnitObs => _didSelectFunctionalUnit; + /// + public override void DidBecomeAvailable(global::ImageCaptureCore.ICScannerDevice scanner) => _didBecomeAvailable.OnNext(scanner); + /// + public override void DidBecomeReady(global::ImageCaptureCore.ICDevice device) => _didBecomeReady.OnNext(device); + /// + public override void DidChangeName(global::ImageCaptureCore.ICDevice device) => _didChangeName.OnNext(device); + /// + public override void DidChangeSharingState(global::ImageCaptureCore.ICDevice device) => _didChangeSharingState.OnNext(device); + /// + public override void DidCloseSession(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error) => _didCloseSession.OnNext((device, error)); + /// + public override void DidCompleteOverviewScan(global::ImageCaptureCore.ICScannerDevice scanner, global::Foundation.NSError error) => _didCompleteOverviewScan.OnNext((scanner, error)); + /// + public override void DidCompleteScan(global::ImageCaptureCore.ICScannerDevice scanner, global::Foundation.NSError error) => _didCompleteScan.OnNext((scanner, error)); + /// + public override void DidEncounterError(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error) => _didEncounterError.OnNext((device, error)); + /// + public override void DidOpenSession(global::ImageCaptureCore.ICDevice device, global::Foundation.NSError error) => _didOpenSession.OnNext((device, error)); + /// + public override void DidReceiveButtonPress(global::ImageCaptureCore.ICDevice device, global::Foundation.NSString buttonType) => _didReceiveButtonPress.OnNext((device, buttonType)); + /// + public override void DidReceiveCustomNotification(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary notification, global::Foundation.NSData data) => _didReceiveCustomNotification.OnNext((device, notification, data)); + /// + public override void DidReceiveStatusInformation(global::ImageCaptureCore.ICDevice device, global::Foundation.NSDictionary status) => _didReceiveStatusInformation.OnNext((device, status)); + /// + public override void DidRemoveDevice(global::ImageCaptureCore.ICDevice device) => _didRemoveDevice.OnNext(device); + /// + public override void DidScanToBandData(global::ImageCaptureCore.ICScannerDevice scanner, global::ImageCaptureCore.ICScannerBandData data) => _didScanToBandData.OnNext((scanner, data)); + /// + public override void DidScanToUrl(global::ImageCaptureCore.ICScannerDevice scanner, global::Foundation.NSUrl url, global::Foundation.NSData data) => _didScanToUrl.OnNext((scanner, url, data)); + /// + public override void DidSelectFunctionalUnit(global::ImageCaptureCore.ICScannerDevice scanner, global::ImageCaptureCore.ICScannerFunctionalUnit functionalUnit, global::Foundation.NSError error) => _didSelectFunctionalUnit.OnNext((scanner, functionalUnit, error)); + } +} + +namespace ImageKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class IKCameraDeviceViewDelegateRx : global::ImageKit.IKCameraDeviceViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKCameraDeviceView cameraDeviceView, global::ImageCaptureCore.ICCameraFile file, global::Foundation.NSUrl url, global::Foundation.NSData data, global::Foundation.NSError error)> _didDownloadFile = new Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKCameraDeviceView cameraDeviceView, global::ImageCaptureCore.ICCameraFile file, global::Foundation.NSUrl url, global::Foundation.NSData data, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKCameraDeviceView cameraDeviceView, global::Foundation.NSError error)> _didEncounterError = new Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKCameraDeviceView cameraDeviceView, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _selectionDidChange = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageKit.IKCameraDeviceView cameraDeviceView, global::ImageCaptureCore.ICCameraFile file, global::Foundation.NSUrl url, global::Foundation.NSData data, global::Foundation.NSError error)> DidDownloadFileObs => _didDownloadFile; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageKit.IKCameraDeviceView cameraDeviceView, global::Foundation.NSError error)> DidEncounterErrorObs => _didEncounterError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SelectionDidChangeObs => _selectionDidChange; + /// + public override void DidDownloadFile(global::ImageKit.IKCameraDeviceView cameraDeviceView, global::ImageCaptureCore.ICCameraFile file, global::Foundation.NSUrl url, global::Foundation.NSData data, global::Foundation.NSError error) => _didDownloadFile.OnNext((cameraDeviceView, file, url, data, error)); + /// + public override void DidEncounterError(global::ImageKit.IKCameraDeviceView cameraDeviceView, global::Foundation.NSError error) => _didEncounterError.OnNext((cameraDeviceView, error)); + /// + public override void SelectionDidChange(global::ImageKit.IKCameraDeviceView cameraDeviceView) => _selectionDidChange.OnNext(cameraDeviceView); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class IKDeviceBrowserViewDelegateRx : global::ImageKit.IKDeviceBrowserViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKDeviceBrowserView deviceBrowserView, global::Foundation.NSError error)> _didEncounterError = new Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKDeviceBrowserView deviceBrowserView, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKDeviceBrowserView deviceBrowserView, global::ImageCaptureCore.ICDevice device)> _selectionDidChange = new Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKDeviceBrowserView deviceBrowserView, global::ImageCaptureCore.ICDevice device)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageKit.IKDeviceBrowserView deviceBrowserView, global::Foundation.NSError error)> DidEncounterErrorObs => _didEncounterError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageKit.IKDeviceBrowserView deviceBrowserView, global::ImageCaptureCore.ICDevice device)> SelectionDidChangeObs => _selectionDidChange; + /// + public override void DidEncounterError(global::ImageKit.IKDeviceBrowserView deviceBrowserView, global::Foundation.NSError error) => _didEncounterError.OnNext((deviceBrowserView, error)); + /// + public override void SelectionDidChange(global::ImageKit.IKDeviceBrowserView deviceBrowserView, global::ImageCaptureCore.ICDevice device) => _selectionDidChange.OnNext((deviceBrowserView, device)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class IKImageBrowserDelegateRx : global::ImageKit.IKImageBrowserDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKImageBrowserView browser, global::AppKit.NSEvent nsevent)> _backgroundWasRightClicked = new Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKImageBrowserView browser, global::AppKit.NSEvent nsevent)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKImageBrowserView browser, global::System.nint index)> _cellWasDoubleClicked = new Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKImageBrowserView browser, global::System.nint index)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKImageBrowserView browser, global::System.nint index, global::AppKit.NSEvent nsevent)> _cellWasRightClicked = new Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKImageBrowserView browser, global::System.nint index, global::AppKit.NSEvent nsevent)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _selectionDidChange = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageKit.IKImageBrowserView browser, global::AppKit.NSEvent nsevent)> BackgroundWasRightClickedObs => _backgroundWasRightClicked; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageKit.IKImageBrowserView browser, global::System.nint index)> CellWasDoubleClickedObs => _cellWasDoubleClicked; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageKit.IKImageBrowserView browser, global::System.nint index, global::AppKit.NSEvent nsevent)> CellWasRightClickedObs => _cellWasRightClicked; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SelectionDidChangeObs => _selectionDidChange; + /// + public override void BackgroundWasRightClicked(global::ImageKit.IKImageBrowserView browser, global::AppKit.NSEvent nsevent) => _backgroundWasRightClicked.OnNext((browser, nsevent)); + /// + public override void CellWasDoubleClicked(global::ImageKit.IKImageBrowserView browser, global::System.nint index) => _cellWasDoubleClicked.OnNext((browser, index)); + /// + public override void CellWasRightClicked(global::ImageKit.IKImageBrowserView browser, global::System.nint index, global::AppKit.NSEvent nsevent) => _cellWasRightClicked.OnNext((browser, index, nsevent)); + /// + public override void SelectionDidChange(global::ImageKit.IKImageBrowserView browser) => _selectionDidChange.OnNext(browser); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class IKScannerDeviceViewDelegateRx : global::ImageKit.IKScannerDeviceViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::Foundation.NSError error)> _didEncounterError = new Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::Foundation.NSUrl url, global::Foundation.NSData data, global::Foundation.NSError error)> _didScan = new Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::Foundation.NSUrl url, global::Foundation.NSData data, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::ImageCaptureCore.ICScannerBandData data, global::Foundation.NSDictionary scanInfo, global::Foundation.NSError error)> _didScanToBandData = new Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::ImageCaptureCore.ICScannerBandData data, global::Foundation.NSDictionary scanInfo, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::Foundation.NSUrl url, global::Foundation.NSError error)> _didScanToUrl = new Pharmacist.Common.SingleAwaitSubject<(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::Foundation.NSUrl url, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::Foundation.NSError error)> DidEncounterErrorObs => _didEncounterError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::Foundation.NSUrl url, global::Foundation.NSData data, global::Foundation.NSError error)> DidScanObs => _didScan; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::ImageCaptureCore.ICScannerBandData data, global::Foundation.NSDictionary scanInfo, global::Foundation.NSError error)> DidScanToBandDataObs => _didScanToBandData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::Foundation.NSUrl url, global::Foundation.NSError error)> DidScanToUrlObs => _didScanToUrl; + /// + public override void DidEncounterError(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::Foundation.NSError error) => _didEncounterError.OnNext((scannerDeviceView, error)); + /// + public override void DidScan(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::Foundation.NSUrl url, global::Foundation.NSData data, global::Foundation.NSError error) => _didScan.OnNext((scannerDeviceView, url, data, error)); + /// + public override void DidScanToBandData(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::ImageCaptureCore.ICScannerBandData data, global::Foundation.NSDictionary scanInfo, global::Foundation.NSError error) => _didScanToBandData.OnNext((scannerDeviceView, data, scanInfo, error)); + /// + public override void DidScanToUrl(global::ImageKit.IKScannerDeviceView scannerDeviceView, global::Foundation.NSUrl url, global::Foundation.NSError error) => _didScanToUrl.OnNext((scannerDeviceView, url, error)); + } +} + +namespace MapKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class MKLocalSearchCompleterDelegateRx : global::MapKit.MKLocalSearchCompleterDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKLocalSearchCompleter completer, global::Foundation.NSError error)> _didFail = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKLocalSearchCompleter completer, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateResults = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKLocalSearchCompleter completer, global::Foundation.NSError error)> DidFailObs => _didFail; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateResultsObs => _didUpdateResults; + /// + public override void DidFail(global::MapKit.MKLocalSearchCompleter completer, global::Foundation.NSError error) => _didFail.OnNext((completer, error)); + /// + public override void DidUpdateResults(global::MapKit.MKLocalSearchCompleter completer) => _didUpdateResults.OnNext(completer); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class MKMapViewDelegateRx : global::MapKit.MKMapViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView annotationView, global::MapKit.MKAnnotationViewDragState newState, global::MapKit.MKAnnotationViewDragState oldState)> _changedDragState = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView annotationView, global::MapKit.MKAnnotationViewDragState newState, global::MapKit.MKAnnotationViewDragState oldState)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView[] views)> _didAddAnnotationViews = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView[] views)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKOverlayRenderer[] renderers)> _didAddOverlayRenderers = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKOverlayRenderer[] renderers)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKUserTrackingMode mode, bool animated)> _didChangeUserTrackingMode = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKUserTrackingMode mode, bool animated)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeVisibleRegion = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view)> _didDeselectAnnotationView = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::Foundation.NSError error)> _didFailToLocateUser = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, bool fullyRendered)> _didFinishRenderingMap = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, bool fullyRendered)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view)> _didSelectAnnotationView = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didStopLocatingUser = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKUserLocation userLocation)> _didUpdateUserLocation = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::MapKit.MKUserLocation userLocation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::Foundation.NSError error)> _loadingMapFailed = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _mapLoaded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, bool animated)> _regionChanged = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, bool animated)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, bool animated)> _regionWillChange = new Pharmacist.Common.SingleAwaitSubject<(global::MapKit.MKMapView mapView, bool animated)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStartLoadingMap = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStartLocatingUser = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStartRenderingMap = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView annotationView, global::MapKit.MKAnnotationViewDragState newState, global::MapKit.MKAnnotationViewDragState oldState)> ChangedDragStateObs => _changedDragState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView[] views)> DidAddAnnotationViewsObs => _didAddAnnotationViews; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKOverlayRenderer[] renderers)> DidAddOverlayRenderersObs => _didAddOverlayRenderers; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKUserTrackingMode mode, bool animated)> DidChangeUserTrackingModeObs => _didChangeUserTrackingMode; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeVisibleRegionObs => _didChangeVisibleRegion; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view)> DidDeselectAnnotationViewObs => _didDeselectAnnotationView; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::Foundation.NSError error)> DidFailToLocateUserObs => _didFailToLocateUser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, bool fullyRendered)> DidFinishRenderingMapObs => _didFinishRenderingMap; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view)> DidSelectAnnotationViewObs => _didSelectAnnotationView; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidStopLocatingUserObs => _didStopLocatingUser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::MapKit.MKUserLocation userLocation)> DidUpdateUserLocationObs => _didUpdateUserLocation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, global::Foundation.NSError error)> LoadingMapFailedObs => _loadingMapFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable MapLoadedObs => _mapLoaded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, bool animated)> RegionChangedObs => _regionChanged; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MapKit.MKMapView mapView, bool animated)> RegionWillChangeObs => _regionWillChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStartLoadingMapObs => _willStartLoadingMap; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStartLocatingUserObs => _willStartLocatingUser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStartRenderingMapObs => _willStartRenderingMap; + /// + public override void ChangedDragState(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView annotationView, global::MapKit.MKAnnotationViewDragState newState, global::MapKit.MKAnnotationViewDragState oldState) => _changedDragState.OnNext((mapView, annotationView, newState, oldState)); + /// + public override void DidAddAnnotationViews(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView[] views) => _didAddAnnotationViews.OnNext((mapView, views)); + /// + public override void DidAddOverlayRenderers(global::MapKit.MKMapView mapView, global::MapKit.MKOverlayRenderer[] renderers) => _didAddOverlayRenderers.OnNext((mapView, renderers)); + /// + public override void DidChangeUserTrackingMode(global::MapKit.MKMapView mapView, global::MapKit.MKUserTrackingMode mode, bool animated) => _didChangeUserTrackingMode.OnNext((mapView, mode, animated)); + /// + public override void DidChangeVisibleRegion(global::MapKit.MKMapView mapView) => _didChangeVisibleRegion.OnNext(mapView); + /// + public override void DidDeselectAnnotationView(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view) => _didDeselectAnnotationView.OnNext((mapView, view)); + /// + public override void DidFailToLocateUser(global::MapKit.MKMapView mapView, global::Foundation.NSError error) => _didFailToLocateUser.OnNext((mapView, error)); + /// + public override void DidFinishRenderingMap(global::MapKit.MKMapView mapView, bool fullyRendered) => _didFinishRenderingMap.OnNext((mapView, fullyRendered)); + /// + public override void DidSelectAnnotationView(global::MapKit.MKMapView mapView, global::MapKit.MKAnnotationView view) => _didSelectAnnotationView.OnNext((mapView, view)); + /// + public override void DidStopLocatingUser(global::MapKit.MKMapView mapView) => _didStopLocatingUser.OnNext(mapView); + /// + public override void DidUpdateUserLocation(global::MapKit.MKMapView mapView, global::MapKit.MKUserLocation userLocation) => _didUpdateUserLocation.OnNext((mapView, userLocation)); + /// + public override void LoadingMapFailed(global::MapKit.MKMapView mapView, global::Foundation.NSError error) => _loadingMapFailed.OnNext((mapView, error)); + /// + public override void MapLoaded(global::MapKit.MKMapView mapView) => _mapLoaded.OnNext(mapView); + /// + public override void RegionChanged(global::MapKit.MKMapView mapView, bool animated) => _regionChanged.OnNext((mapView, animated)); + /// + public override void RegionWillChange(global::MapKit.MKMapView mapView, bool animated) => _regionWillChange.OnNext((mapView, animated)); + /// + public override void WillStartLoadingMap(global::MapKit.MKMapView mapView) => _willStartLoadingMap.OnNext(mapView); + /// + public override void WillStartLocatingUser(global::MapKit.MKMapView mapView) => _willStartLocatingUser.OnNext(mapView); + /// + public override void WillStartRenderingMap(global::MapKit.MKMapView mapView) => _willStartRenderingMap.OnNext(mapView); + } +} + +namespace MetalKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class MTKViewDelegateRx : global::MetalKit.MTKViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _draw = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MetalKit.MTKView view, global::CoreGraphics.CGSize size)> _drawableSizeWillChange = new Pharmacist.Common.SingleAwaitSubject<(global::MetalKit.MTKView view, global::CoreGraphics.CGSize size)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DrawObs => _draw; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MetalKit.MTKView view, global::CoreGraphics.CGSize size)> DrawableSizeWillChangeObs => _drawableSizeWillChange; + /// + public override void Draw(global::MetalKit.MTKView view) => _draw.OnNext(view); + /// + public override void DrawableSizeWillChange(global::MetalKit.MTKView view, global::CoreGraphics.CGSize size) => _drawableSizeWillChange.OnNext((view, size)); + } +} + +namespace MultipeerConnectivity +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class MCAdvertiserAssistantDelegateRx : global::MultipeerConnectivity.MCAdvertiserAssistantDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didDismissInvitation = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willPresentInvitation = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDismissInvitationObs => _didDismissInvitation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillPresentInvitationObs => _willPresentInvitation; + /// + public override void DidDismissInvitation(global::MultipeerConnectivity.MCAdvertiserAssistant advertiserAssistant) => _didDismissInvitation.OnNext(advertiserAssistant); + /// + public override void WillPresentInvitation(global::MultipeerConnectivity.MCAdvertiserAssistant advertiserAssistant) => _willPresentInvitation.OnNext(advertiserAssistant); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class MCBrowserViewControllerDelegateRx : global::MultipeerConnectivity.MCBrowserViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didFinish = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _wasCancelled = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishObs => _didFinish; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WasCancelledObs => _wasCancelled; + /// + public override void DidFinish(global::MultipeerConnectivity.MCBrowserViewController browserViewController) => _didFinish.OnNext(browserViewController); + /// + public override void WasCancelled(global::MultipeerConnectivity.MCBrowserViewController browserViewController) => _wasCancelled.OnNext(browserViewController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class MCNearbyServiceAdvertiserDelegateRx : global::MultipeerConnectivity.MCNearbyServiceAdvertiserDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::Foundation.NSError error)> _didNotStartAdvertisingPeer = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSData context, global::MultipeerConnectivity.MCNearbyServiceAdvertiserInvitationHandler invitationHandler)> _didReceiveInvitationFromPeer = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSData context, global::MultipeerConnectivity.MCNearbyServiceAdvertiserInvitationHandler invitationHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::Foundation.NSError error)> DidNotStartAdvertisingPeerObs => _didNotStartAdvertisingPeer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSData context, global::MultipeerConnectivity.MCNearbyServiceAdvertiserInvitationHandler invitationHandler)> DidReceiveInvitationFromPeerObs => _didReceiveInvitationFromPeer; + /// + public override void DidNotStartAdvertisingPeer(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::Foundation.NSError error) => _didNotStartAdvertisingPeer.OnNext((advertiser, error)); + /// + public override void DidReceiveInvitationFromPeer(global::MultipeerConnectivity.MCNearbyServiceAdvertiser advertiser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSData context, global::MultipeerConnectivity.MCNearbyServiceAdvertiserInvitationHandler invitationHandler) => _didReceiveInvitationFromPeer.OnNext((advertiser, peerID, context, invitationHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class MCNearbyServiceBrowserDelegateRx : global::MultipeerConnectivity.MCNearbyServiceBrowserDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::Foundation.NSError error)> _didNotStartBrowsingForPeers = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSDictionary info)> _foundPeer = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSDictionary info)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID)> _lostPeer = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::Foundation.NSError error)> DidNotStartBrowsingForPeersObs => _didNotStartBrowsingForPeers; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSDictionary info)> FoundPeerObs => _foundPeer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID)> LostPeerObs => _lostPeer; + /// + public override void DidNotStartBrowsingForPeers(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::Foundation.NSError error) => _didNotStartBrowsingForPeers.OnNext((browser, error)); + /// + public override void FoundPeer(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID, global::Foundation.NSDictionary info) => _foundPeer.OnNext((browser, peerID, info)); + /// + public override void LostPeer(global::MultipeerConnectivity.MCNearbyServiceBrowser browser, global::MultipeerConnectivity.MCPeerID peerID) => _lostPeer.OnNext((browser, peerID)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class MCSessionDelegateRx : global::MultipeerConnectivity.MCSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, global::MultipeerConnectivity.MCPeerID peerID, global::MultipeerConnectivity.MCSessionState state)> _didChangeState = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, global::MultipeerConnectivity.MCPeerID peerID, global::MultipeerConnectivity.MCSessionState state)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSUrl localUrl, global::Foundation.NSError error)> _didFinishReceivingResource = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSUrl localUrl, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, global::Foundation.NSData data, global::MultipeerConnectivity.MCPeerID peerID)> _didReceiveData = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, global::Foundation.NSData data, global::MultipeerConnectivity.MCPeerID peerID)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, global::Foundation.NSInputStream stream, string streamName, global::MultipeerConnectivity.MCPeerID peerID)> _didReceiveStream = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, global::Foundation.NSInputStream stream, string streamName, global::MultipeerConnectivity.MCPeerID peerID)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSProgress progress)> _didStartReceivingResource = new Pharmacist.Common.SingleAwaitSubject<(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSProgress progress)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCSession session, global::MultipeerConnectivity.MCPeerID peerID, global::MultipeerConnectivity.MCSessionState state)> DidChangeStateObs => _didChangeState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSUrl localUrl, global::Foundation.NSError error)> DidFinishReceivingResourceObs => _didFinishReceivingResource; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCSession session, global::Foundation.NSData data, global::MultipeerConnectivity.MCPeerID peerID)> DidReceiveDataObs => _didReceiveData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCSession session, global::Foundation.NSInputStream stream, string streamName, global::MultipeerConnectivity.MCPeerID peerID)> DidReceiveStreamObs => _didReceiveStream; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSProgress progress)> DidStartReceivingResourceObs => _didStartReceivingResource; + /// + public override void DidChangeState(global::MultipeerConnectivity.MCSession session, global::MultipeerConnectivity.MCPeerID peerID, global::MultipeerConnectivity.MCSessionState state) => _didChangeState.OnNext((session, peerID, state)); + /// + public override void DidFinishReceivingResource(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSUrl localUrl, global::Foundation.NSError error) => _didFinishReceivingResource.OnNext((session, resourceName, fromPeer, localUrl, error)); + /// + public override void DidReceiveData(global::MultipeerConnectivity.MCSession session, global::Foundation.NSData data, global::MultipeerConnectivity.MCPeerID peerID) => _didReceiveData.OnNext((session, data, peerID)); + /// + public override void DidReceiveStream(global::MultipeerConnectivity.MCSession session, global::Foundation.NSInputStream stream, string streamName, global::MultipeerConnectivity.MCPeerID peerID) => _didReceiveStream.OnNext((session, stream, streamName, peerID)); + /// + public override void DidStartReceivingResource(global::MultipeerConnectivity.MCSession session, string resourceName, global::MultipeerConnectivity.MCPeerID fromPeer, global::Foundation.NSProgress progress) => _didStartReceivingResource.OnNext((session, resourceName, fromPeer, progress)); + } +} + +namespace NetworkExtension +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class NWTcpConnectionAuthenticationDelegateRx : global::NetworkExtension.NWTcpConnectionAuthenticationDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::NetworkExtension.NWTcpConnection connection, global::Foundation.NSArray peerCertificateChain, global::System.Action completion)> _evaluateTrust = new Pharmacist.Common.SingleAwaitSubject<(global::NetworkExtension.NWTcpConnection connection, global::Foundation.NSArray peerCertificateChain, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::NetworkExtension.NWTcpConnection connection, global::System.Action completion)> _provideIdentity = new Pharmacist.Common.SingleAwaitSubject<(global::NetworkExtension.NWTcpConnection connection, global::System.Action completion)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::NetworkExtension.NWTcpConnection connection, global::Foundation.NSArray peerCertificateChain, global::System.Action completion)> EvaluateTrustObs => _evaluateTrust; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::NetworkExtension.NWTcpConnection connection, global::System.Action completion)> ProvideIdentityObs => _provideIdentity; + /// + public override void EvaluateTrust(global::NetworkExtension.NWTcpConnection connection, global::Foundation.NSArray peerCertificateChain, global::System.Action completion) => _evaluateTrust.OnNext((connection, peerCertificateChain, completion)); + /// + public override void ProvideIdentity(global::NetworkExtension.NWTcpConnection connection, global::System.Action completion) => _provideIdentity.OnNext((connection, completion)); + } +} + +namespace NotificationCenter +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NCWidgetListViewDelegateRx : global::NotificationCenter.NCWidgetListViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::NotificationCenter.NCWidgetListViewController list, global::System.nuint row)> _didRemoveRow = new Pharmacist.Common.SingleAwaitSubject<(global::NotificationCenter.NCWidgetListViewController list, global::System.nuint row)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::NotificationCenter.NCWidgetListViewController list, global::System.nuint row, global::System.nuint newIndex)> _didReorderRow = new Pharmacist.Common.SingleAwaitSubject<(global::NotificationCenter.NCWidgetListViewController list, global::System.nuint row, global::System.nuint newIndex)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _performAddAction = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::NotificationCenter.NCWidgetListViewController list, global::System.nuint row)> DidRemoveRowObs => _didRemoveRow; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::NotificationCenter.NCWidgetListViewController list, global::System.nuint row, global::System.nuint newIndex)> DidReorderRowObs => _didReorderRow; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PerformAddActionObs => _performAddAction; + /// + public override void DidRemoveRow(global::NotificationCenter.NCWidgetListViewController list, global::System.nuint row) => _didRemoveRow.OnNext((list, row)); + /// + public override void DidReorderRow(global::NotificationCenter.NCWidgetListViewController list, global::System.nuint row, global::System.nuint newIndex) => _didReorderRow.OnNext((list, row, newIndex)); + /// + public override void PerformAddAction(global::NotificationCenter.NCWidgetListViewController list) => _performAddAction.OnNext(list); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NCWidgetSearchViewDelegateRx : global::NotificationCenter.NCWidgetSearchViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::NotificationCenter.NCWidgetSearchViewController controller, global::Foundation.NSObject obj)> _resultSelected = new Pharmacist.Common.SingleAwaitSubject<(global::NotificationCenter.NCWidgetSearchViewController controller, global::Foundation.NSObject obj)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::NotificationCenter.NCWidgetSearchViewController controller, string searchTerm, global::System.nuint max)> _searchForTearm = new Pharmacist.Common.SingleAwaitSubject<(global::NotificationCenter.NCWidgetSearchViewController controller, string searchTerm, global::System.nuint max)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _termCleared = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::NotificationCenter.NCWidgetSearchViewController controller, global::Foundation.NSObject obj)> ResultSelectedObs => _resultSelected; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::NotificationCenter.NCWidgetSearchViewController controller, string searchTerm, global::System.nuint max)> SearchForTearmObs => _searchForTearm; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable TermClearedObs => _termCleared; + /// + public override void ResultSelected(global::NotificationCenter.NCWidgetSearchViewController controller, global::Foundation.NSObject obj) => _resultSelected.OnNext((controller, obj)); + /// + public override void SearchForTearm(global::NotificationCenter.NCWidgetSearchViewController controller, string searchTerm, global::System.nuint max) => _searchForTearm.OnNext((controller, searchTerm, max)); + /// + public override void TermCleared(global::NotificationCenter.NCWidgetSearchViewController controller) => _termCleared.OnNext(controller); + } +} + +namespace PassKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class PKPaymentAuthorizationControllerDelegateRx : global::PassKit.PKPaymentAuthorizationControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPayment payment, global::System.Action completion)> _didAuthorizePayment = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPayment payment, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinish = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::System.Action handler)> _didRequestMerchantSessionUpdate = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::System.Action handler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)> _didSelectPaymentMethod = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKContact contact, global::System.Action completion)> _didSelectShippingContact = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKContact contact, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)> _didSelectShippingMethod = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willAuthorizePayment = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPayment payment, global::System.Action completion)> DidAuthorizePaymentObs => _didAuthorizePayment; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishObs => _didFinish; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationController controller, global::System.Action handler)> DidRequestMerchantSessionUpdateObs => _didRequestMerchantSessionUpdate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)> DidSelectPaymentMethodObs => _didSelectPaymentMethod; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKContact contact, global::System.Action completion)> DidSelectShippingContactObs => _didSelectShippingContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)> DidSelectShippingMethodObs => _didSelectShippingMethod; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillAuthorizePaymentObs => _willAuthorizePayment; + /// + public override void DidAuthorizePayment(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPayment payment, global::System.Action completion) => _didAuthorizePayment.OnNext((controller, payment, completion)); + /// + public override void DidFinish(global::PassKit.PKPaymentAuthorizationController controller) => _didFinish.OnNext(controller); + /// + public override void DidRequestMerchantSessionUpdate(global::PassKit.PKPaymentAuthorizationController controller, global::System.Action handler) => _didRequestMerchantSessionUpdate.OnNext((controller, handler)); + /// + public override void DidSelectPaymentMethod(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion) => _didSelectPaymentMethod.OnNext((controller, paymentMethod, completion)); + /// + public override void DidSelectShippingContact(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKContact contact, global::System.Action completion) => _didSelectShippingContact.OnNext((controller, contact, completion)); + /// + public override void DidSelectShippingMethod(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion) => _didSelectShippingMethod.OnNext((controller, paymentMethod, completion)); + /// + public override void WillAuthorizePayment(global::PassKit.PKPaymentAuthorizationController controller) => _willAuthorizePayment.OnNext(controller); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class PKPaymentAuthorizationViewControllerDelegateRx : global::PassKit.PKPaymentAuthorizationViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPayment payment, global::System.Action completion)> _didAuthorizePayment2 = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPayment payment, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::System.Action updateHandler)> _didRequestMerchantSessionUpdate = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::System.Action updateHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)> _didSelectPaymentMethod2 = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKContact contact, global::System.Action completion)> _didSelectShippingContact2 = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKContact contact, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion)> _didSelectShippingMethod2 = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _paymentAuthorizationViewControllerDidFinish = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willAuthorizePayment = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPayment payment, global::System.Action completion)> DidAuthorizePayment2Obs => _didAuthorizePayment2; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationViewController controller, global::System.Action updateHandler)> DidRequestMerchantSessionUpdateObs => _didRequestMerchantSessionUpdate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)> DidSelectPaymentMethod2Obs => _didSelectPaymentMethod2; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKContact contact, global::System.Action completion)> DidSelectShippingContact2Obs => _didSelectShippingContact2; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion)> DidSelectShippingMethod2Obs => _didSelectShippingMethod2; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PaymentAuthorizationViewControllerDidFinishObs => _paymentAuthorizationViewControllerDidFinish; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillAuthorizePaymentObs => _willAuthorizePayment; + /// + public override void DidAuthorizePayment2(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPayment payment, global::System.Action completion) => _didAuthorizePayment2.OnNext((controller, payment, completion)); + /// + public override void DidRequestMerchantSessionUpdate(global::PassKit.PKPaymentAuthorizationViewController controller, global::System.Action updateHandler) => _didRequestMerchantSessionUpdate.OnNext((controller, updateHandler)); + /// + public override void DidSelectPaymentMethod2(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion) => _didSelectPaymentMethod2.OnNext((controller, paymentMethod, completion)); + /// + public override void DidSelectShippingContact2(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKContact contact, global::System.Action completion) => _didSelectShippingContact2.OnNext((controller, contact, completion)); + /// + public override void DidSelectShippingMethod2(global::PassKit.PKPaymentAuthorizationViewController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion) => _didSelectShippingMethod2.OnNext((controller, shippingMethod, completion)); + /// + public override void PaymentAuthorizationViewControllerDidFinish(global::PassKit.PKPaymentAuthorizationViewController controller) => _paymentAuthorizationViewControllerDidFinish.OnNext(controller); + /// + public override void WillAuthorizePayment(global::PassKit.PKPaymentAuthorizationViewController controller) => _willAuthorizePayment.OnNext(controller); + } +} + +namespace PdfKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class PdfDocumentDelegateRx : global::PdfKit.PdfDocumentDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBeginDocumentFind = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didMatchString = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUnlock = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _findFinished = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _matchFound = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _pageFindFinished = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _pageFindStarted = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBeginDocumentFindObs => _didBeginDocumentFind; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidMatchStringObs => _didMatchString; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUnlockObs => _didUnlock; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FindFinishedObs => _findFinished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable MatchFoundObs => _matchFound; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PageFindFinishedObs => _pageFindFinished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PageFindStartedObs => _pageFindStarted; + /// + public override void DidBeginDocumentFind(global::Foundation.NSNotification notification) => _didBeginDocumentFind.OnNext(notification); + /// + public override void DidMatchString(global::PdfKit.PdfSelection sender) => _didMatchString.OnNext(sender); + /// + public override void DidUnlock(global::Foundation.NSNotification notification) => _didUnlock.OnNext(notification); + /// + public override void FindFinished(global::Foundation.NSNotification notification) => _findFinished.OnNext(notification); + /// + public override void MatchFound(global::Foundation.NSNotification notification) => _matchFound.OnNext(notification); + /// + public override void PageFindFinished(global::Foundation.NSNotification notification) => _pageFindFinished.OnNext(notification); + /// + public override void PageFindStarted(global::Foundation.NSNotification notification) => _pageFindStarted.OnNext(notification); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class PdfViewDelegateRx : global::PdfKit.PdfViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PdfKit.PdfView sender, global::PdfKit.PdfActionRemoteGoTo action)> _openPdf = new Pharmacist.Common.SingleAwaitSubject<(global::PdfKit.PdfView sender, global::PdfKit.PdfActionRemoteGoTo action)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _performFind = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _performGoToPage = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _performPrint = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PdfKit.PdfView sender, global::Foundation.NSUrl url)> _willClickOnLink = new Pharmacist.Common.SingleAwaitSubject<(global::PdfKit.PdfView sender, global::Foundation.NSUrl url)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PdfKit.PdfView sender, global::PdfKit.PdfActionRemoteGoTo action)> OpenPdfObs => _openPdf; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PerformFindObs => _performFind; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PerformGoToPageObs => _performGoToPage; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable PerformPrintObs => _performPrint; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PdfKit.PdfView sender, global::Foundation.NSUrl url)> WillClickOnLinkObs => _willClickOnLink; + /// + public override void OpenPdf(global::PdfKit.PdfView sender, global::PdfKit.PdfActionRemoteGoTo action) => _openPdf.OnNext((sender, action)); + /// + public override void PerformFind(global::PdfKit.PdfView sender) => _performFind.OnNext(sender); + /// + public override void PerformGoToPage(global::PdfKit.PdfView sender) => _performGoToPage.OnNext(sender); + /// + public override void PerformPrint(global::PdfKit.PdfView sender) => _performPrint.OnNext(sender); + /// + public override void WillClickOnLink(global::PdfKit.PdfView sender, global::Foundation.NSUrl url) => _willClickOnLink.OnNext((sender, url)); + } +} + +namespace PhotosUI +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class PHLivePhotoViewDelegateRx : global::PhotosUI.PHLivePhotoViewDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle)> _didEndPlayback = new Pharmacist.Common.SingleAwaitSubject<(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle)> _willBeginPlayback = new Pharmacist.Common.SingleAwaitSubject<(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle)> DidEndPlaybackObs => _didEndPlayback; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle)> WillBeginPlaybackObs => _willBeginPlayback; + /// + public override void DidEndPlayback(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle) => _didEndPlayback.OnNext((livePhotoView, playbackStyle)); + /// + public override void WillBeginPlayback(global::PhotosUI.PHLivePhotoView livePhotoView, global::PhotosUI.PHLivePhotoViewPlaybackStyle playbackStyle) => _willBeginPlayback.OnNext((livePhotoView, playbackStyle)); + } +} + +namespace PushKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class PKPushRegistryDelegateRx : global::PushKit.PKPushRegistryDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, string type)> _didInvalidatePushToken = new Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, string type)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushPayload payload, string type, global::System.Action completion)> _didReceiveIncomingPush = new Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushPayload payload, string type, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushCredentials credentials, string type)> _didUpdatePushCredentials = new Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushCredentials credentials, string type)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PushKit.PKPushRegistry registry, string type)> DidInvalidatePushTokenObs => _didInvalidatePushToken; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushPayload payload, string type, global::System.Action completion)> DidReceiveIncomingPushObs => _didReceiveIncomingPush; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushCredentials credentials, string type)> DidUpdatePushCredentialsObs => _didUpdatePushCredentials; + /// + public override void DidInvalidatePushToken(global::PushKit.PKPushRegistry registry, string type) => _didInvalidatePushToken.OnNext((registry, type)); + /// + public override void DidReceiveIncomingPush(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushPayload payload, string type, global::System.Action completion) => _didReceiveIncomingPush.OnNext((registry, payload, type, completion)); + /// + public override void DidUpdatePushCredentials(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushCredentials credentials, string type) => _didUpdatePushCredentials.OnNext((registry, credentials, type)); + } +} + +namespace QTKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class QTCaptureDecompressedVideoOutputDelegateRx : global::QTKit.QTCaptureDecompressedVideoOutputDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureOutput captureOutput, global::QTKit.QTSampleBuffer sampleBuffer, global::QTKit.QTCaptureConnection connection)> _didDropVideoFrame = new Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureOutput captureOutput, global::QTKit.QTSampleBuffer sampleBuffer, global::QTKit.QTCaptureConnection connection)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureOutput captureOutput, global::CoreVideo.CVImageBuffer videoFrame, global::QTKit.QTSampleBuffer sampleBuffer, global::QTKit.QTCaptureConnection connection)> _didOutputVideoFrame = new Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureOutput captureOutput, global::CoreVideo.CVImageBuffer videoFrame, global::QTKit.QTSampleBuffer sampleBuffer, global::QTKit.QTCaptureConnection connection)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::QTKit.QTCaptureOutput captureOutput, global::QTKit.QTSampleBuffer sampleBuffer, global::QTKit.QTCaptureConnection connection)> DidDropVideoFrameObs => _didDropVideoFrame; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::QTKit.QTCaptureOutput captureOutput, global::CoreVideo.CVImageBuffer videoFrame, global::QTKit.QTSampleBuffer sampleBuffer, global::QTKit.QTCaptureConnection connection)> DidOutputVideoFrameObs => _didOutputVideoFrame; + /// + public override void DidDropVideoFrame(global::QTKit.QTCaptureOutput captureOutput, global::QTKit.QTSampleBuffer sampleBuffer, global::QTKit.QTCaptureConnection connection) => _didDropVideoFrame.OnNext((captureOutput, sampleBuffer, connection)); + /// + public override void DidOutputVideoFrame(global::QTKit.QTCaptureOutput captureOutput, global::CoreVideo.CVImageBuffer videoFrame, global::QTKit.QTSampleBuffer sampleBuffer, global::QTKit.QTCaptureConnection connection) => _didOutputVideoFrame.OnNext((captureOutput, videoFrame, sampleBuffer, connection)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class QTCaptureFileOutputDelegateRx : global::QTKit.QTCaptureFileOutputDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileURL, global::QTKit.QTCaptureConnection[] connections, global::Foundation.NSError reason)> _didFinishRecording = new Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileURL, global::QTKit.QTCaptureConnection[] connections, global::Foundation.NSError reason)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::QTKit.QTSampleBuffer sampleBuffer, global::QTKit.QTCaptureConnection connection)> _didOutputSampleBuffer = new Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::QTKit.QTSampleBuffer sampleBuffer, global::QTKit.QTCaptureConnection connection)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections)> _didPauseRecording = new Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections)> _didResumeRecording = new Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections)> _didStartRecording = new Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileURL, global::QTKit.QTCaptureConnection[] connections, global::Foundation.NSError reason)> _mustChangeOutputFile = new Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileURL, global::QTKit.QTCaptureConnection[] connections, global::Foundation.NSError reason)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileURL, global::QTKit.QTCaptureConnection[] connections, global::Foundation.NSError reason)> _willFinishRecording = new Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileURL, global::QTKit.QTCaptureConnection[] connections, global::Foundation.NSError reason)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections)> _willStartRecording = new Pharmacist.Common.SingleAwaitSubject<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileURL, global::QTKit.QTCaptureConnection[] connections, global::Foundation.NSError reason)> DidFinishRecordingObs => _didFinishRecording; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::QTKit.QTCaptureFileOutput captureOutput, global::QTKit.QTSampleBuffer sampleBuffer, global::QTKit.QTCaptureConnection connection)> DidOutputSampleBufferObs => _didOutputSampleBuffer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections)> DidPauseRecordingObs => _didPauseRecording; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections)> DidResumeRecordingObs => _didResumeRecording; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections)> DidStartRecordingObs => _didStartRecording; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileURL, global::QTKit.QTCaptureConnection[] connections, global::Foundation.NSError reason)> MustChangeOutputFileObs => _mustChangeOutputFile; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileURL, global::QTKit.QTCaptureConnection[] connections, global::Foundation.NSError reason)> WillFinishRecordingObs => _willFinishRecording; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections)> WillStartRecordingObs => _willStartRecording; + /// + public override void DidFinishRecording(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileURL, global::QTKit.QTCaptureConnection[] connections, global::Foundation.NSError reason) => _didFinishRecording.OnNext((captureOutput, outputFileURL, connections, reason)); + /// + public override void DidOutputSampleBuffer(global::QTKit.QTCaptureFileOutput captureOutput, global::QTKit.QTSampleBuffer sampleBuffer, global::QTKit.QTCaptureConnection connection) => _didOutputSampleBuffer.OnNext((captureOutput, sampleBuffer, connection)); + /// + public override void DidPauseRecording(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections) => _didPauseRecording.OnNext((captureOutput, fileUrl, connections)); + /// + public override void DidResumeRecording(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections) => _didResumeRecording.OnNext((captureOutput, fileUrl, connections)); + /// + public override void DidStartRecording(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections) => _didStartRecording.OnNext((captureOutput, fileUrl, connections)); + /// + public override void MustChangeOutputFile(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileURL, global::QTKit.QTCaptureConnection[] connections, global::Foundation.NSError reason) => _mustChangeOutputFile.OnNext((captureOutput, outputFileURL, connections, reason)); + /// + public override void WillFinishRecording(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl outputFileURL, global::QTKit.QTCaptureConnection[] connections, global::Foundation.NSError reason) => _willFinishRecording.OnNext((captureOutput, outputFileURL, connections, reason)); + /// + public override void WillStartRecording(global::QTKit.QTCaptureFileOutput captureOutput, global::Foundation.NSUrl fileUrl, global::QTKit.QTCaptureConnection[] connections) => _willStartRecording.OnNext((captureOutput, fileUrl, connections)); + } +} + +namespace QuickLookUI +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class QLPreviewPanelDelegateRx : global::QuickLookUI.QLPreviewPanelDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeKey = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didBecomeMain = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeBackingProperties = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeScreen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeScreenProfile = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, global::Foundation.NSCoder coder)> _didDecodeRestorableState = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, global::Foundation.NSCoder coder)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didDeminiaturize = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEndLiveResize = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEndSheet = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEnterFullScreen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEnterVersionBrowser = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didExitFullScreen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didExitVersionBrowser = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didExpose = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFailToEnterFullScreen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFailToExitFullScreen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didMiniaturize = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didMove = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didResignKey = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didResignMain = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didResize = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdate = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, double duration)> _startCustomAnimationToEnterFullScreen = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, double duration)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, double duration)> _startCustomAnimationToExitFullScreen = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, double duration)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willBeginSheet = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willClose = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, global::Foundation.NSCoder coder)> _willEncodeRestorableState = new Pharmacist.Common.SingleAwaitSubject<(global::AppKit.NSWindow window, global::Foundation.NSCoder coder)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willEnterFullScreen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willEnterVersionBrowser = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willExitFullScreen = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willExitVersionBrowser = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willMiniaturize = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willMove = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willStartLiveResize = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeKeyObs => _didBecomeKey; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBecomeMainObs => _didBecomeMain; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeBackingPropertiesObs => _didChangeBackingProperties; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeScreenObs => _didChangeScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeScreenProfileObs => _didChangeScreenProfile; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSWindow window, global::Foundation.NSCoder coder)> DidDecodeRestorableStateObs => _didDecodeRestorableState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDeminiaturizeObs => _didDeminiaturize; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndLiveResizeObs => _didEndLiveResize; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndSheetObs => _didEndSheet; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEnterFullScreenObs => _didEnterFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEnterVersionBrowserObs => _didEnterVersionBrowser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidExitFullScreenObs => _didExitFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidExitVersionBrowserObs => _didExitVersionBrowser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidExposeObs => _didExpose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFailToEnterFullScreenObs => _didFailToEnterFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFailToExitFullScreenObs => _didFailToExitFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidMiniaturizeObs => _didMiniaturize; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidMoveObs => _didMove; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidResignKeyObs => _didResignKey; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidResignMainObs => _didResignMain; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidResizeObs => _didResize; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateObs => _didUpdate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSWindow window, double duration)> StartCustomAnimationToEnterFullScreenObs => _startCustomAnimationToEnterFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSWindow window, double duration)> StartCustomAnimationToExitFullScreenObs => _startCustomAnimationToExitFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillBeginSheetObs => _willBeginSheet; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillCloseObs => _willClose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AppKit.NSWindow window, global::Foundation.NSCoder coder)> WillEncodeRestorableStateObs => _willEncodeRestorableState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillEnterFullScreenObs => _willEnterFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillEnterVersionBrowserObs => _willEnterVersionBrowser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillExitFullScreenObs => _willExitFullScreen; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillExitVersionBrowserObs => _willExitVersionBrowser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillMiniaturizeObs => _willMiniaturize; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillMoveObs => _willMove; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillStartLiveResizeObs => _willStartLiveResize; + /// + public override void DidBecomeKey(global::Foundation.NSNotification notification) => _didBecomeKey.OnNext(notification); + /// + public override void DidBecomeMain(global::Foundation.NSNotification notification) => _didBecomeMain.OnNext(notification); + /// + public override void DidChangeBackingProperties(global::Foundation.NSNotification notification) => _didChangeBackingProperties.OnNext(notification); + /// + public override void DidChangeScreen(global::Foundation.NSNotification notification) => _didChangeScreen.OnNext(notification); + /// + public override void DidChangeScreenProfile(global::Foundation.NSNotification notification) => _didChangeScreenProfile.OnNext(notification); + /// + public override void DidDecodeRestorableState(global::AppKit.NSWindow window, global::Foundation.NSCoder coder) => _didDecodeRestorableState.OnNext((window, coder)); + /// + public override void DidDeminiaturize(global::Foundation.NSNotification notification) => _didDeminiaturize.OnNext(notification); + /// + public override void DidEndLiveResize(global::Foundation.NSNotification notification) => _didEndLiveResize.OnNext(notification); + /// + public override void DidEndSheet(global::Foundation.NSNotification notification) => _didEndSheet.OnNext(notification); + /// + public override void DidEnterFullScreen(global::Foundation.NSNotification notification) => _didEnterFullScreen.OnNext(notification); + /// + public override void DidEnterVersionBrowser(global::Foundation.NSNotification notification) => _didEnterVersionBrowser.OnNext(notification); + /// + public override void DidExitFullScreen(global::Foundation.NSNotification notification) => _didExitFullScreen.OnNext(notification); + /// + public override void DidExitVersionBrowser(global::Foundation.NSNotification notification) => _didExitVersionBrowser.OnNext(notification); + /// + public override void DidExpose(global::Foundation.NSNotification notification) => _didExpose.OnNext(notification); + /// + public override void DidFailToEnterFullScreen(global::AppKit.NSWindow window) => _didFailToEnterFullScreen.OnNext(window); + /// + public override void DidFailToExitFullScreen(global::AppKit.NSWindow window) => _didFailToExitFullScreen.OnNext(window); + /// + public override void DidMiniaturize(global::Foundation.NSNotification notification) => _didMiniaturize.OnNext(notification); + /// + public override void DidMove(global::Foundation.NSNotification notification) => _didMove.OnNext(notification); + /// + public override void DidResignKey(global::Foundation.NSNotification notification) => _didResignKey.OnNext(notification); + /// + public override void DidResignMain(global::Foundation.NSNotification notification) => _didResignMain.OnNext(notification); + /// + public override void DidResize(global::Foundation.NSNotification notification) => _didResize.OnNext(notification); + /// + public override void DidUpdate(global::Foundation.NSNotification notification) => _didUpdate.OnNext(notification); + /// + public override void StartCustomAnimationToEnterFullScreen(global::AppKit.NSWindow window, double duration) => _startCustomAnimationToEnterFullScreen.OnNext((window, duration)); + /// + public override void StartCustomAnimationToExitFullScreen(global::AppKit.NSWindow window, double duration) => _startCustomAnimationToExitFullScreen.OnNext((window, duration)); + /// + public override void WillBeginSheet(global::Foundation.NSNotification notification) => _willBeginSheet.OnNext(notification); + /// + public override void WillClose(global::Foundation.NSNotification notification) => _willClose.OnNext(notification); + /// + public override void WillEncodeRestorableState(global::AppKit.NSWindow window, global::Foundation.NSCoder coder) => _willEncodeRestorableState.OnNext((window, coder)); + /// + public override void WillEnterFullScreen(global::Foundation.NSNotification notification) => _willEnterFullScreen.OnNext(notification); + /// + public override void WillEnterVersionBrowser(global::Foundation.NSNotification notification) => _willEnterVersionBrowser.OnNext(notification); + /// + public override void WillExitFullScreen(global::Foundation.NSNotification notification) => _willExitFullScreen.OnNext(notification); + /// + public override void WillExitVersionBrowser(global::Foundation.NSNotification notification) => _willExitVersionBrowser.OnNext(notification); + /// + public override void WillMiniaturize(global::Foundation.NSNotification notification) => _willMiniaturize.OnNext(notification); + /// + public override void WillMove(global::Foundation.NSNotification notification) => _willMove.OnNext(notification); + /// + public override void WillStartLiveResize(global::Foundation.NSNotification notification) => _willStartLiveResize.OnNext(notification); + } +} + +namespace ReplayKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class RPBroadcastActivityControllerDelegateRx : global::ReplayKit.RPBroadcastActivityControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastActivityController broadcastActivityController, global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error)> _didFinish = new Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastActivityController broadcastActivityController, global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ReplayKit.RPBroadcastActivityController broadcastActivityController, global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error)> DidFinishObs => _didFinish; + /// + public override void DidFinish(global::ReplayKit.RPBroadcastActivityController broadcastActivityController, global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error) => _didFinish.OnNext((broadcastActivityController, broadcastController, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class RPBroadcastControllerDelegateRx : global::ReplayKit.RPBroadcastControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error)> _didFinish = new Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSUrl broadcastUrl)> _didUpdateBroadcastUrl = new Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSUrl broadcastUrl)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSDictionary serviceInfo)> _didUpdateServiceInfo = new Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSDictionary serviceInfo)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error)> DidFinishObs => _didFinish; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSUrl broadcastUrl)> DidUpdateBroadcastUrlObs => _didUpdateBroadcastUrl; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSDictionary serviceInfo)> DidUpdateServiceInfoObs => _didUpdateServiceInfo; + /// + public override void DidFinish(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSError error) => _didFinish.OnNext((broadcastController, error)); + /// + public override void DidUpdateBroadcastUrl(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSUrl broadcastUrl) => _didUpdateBroadcastUrl.OnNext((broadcastController, broadcastUrl)); + /// + public override void DidUpdateServiceInfo(global::ReplayKit.RPBroadcastController broadcastController, global::Foundation.NSDictionary serviceInfo) => _didUpdateServiceInfo.OnNext((broadcastController, serviceInfo)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class RPPreviewViewControllerDelegateRx : global::ReplayKit.RPPreviewViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPPreviewViewController previewController, global::Foundation.NSSet activityTypes)> _didFinish = new Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPPreviewViewController previewController, global::Foundation.NSSet activityTypes)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ReplayKit.RPPreviewViewController previewController, global::Foundation.NSSet activityTypes)> DidFinishObs => _didFinish; + /// + public override void DidFinish(global::ReplayKit.RPPreviewViewController previewController, global::Foundation.NSSet activityTypes) => _didFinish.OnNext((previewController, activityTypes)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class RPScreenRecorderDelegateRx : global::ReplayKit.RPScreenRecorderDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeAvailability = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPScreenRecorder screenRecorder, global::ReplayKit.RPPreviewViewController previewViewController, global::Foundation.NSError error)> _didStopRecording = new Pharmacist.Common.SingleAwaitSubject<(global::ReplayKit.RPScreenRecorder screenRecorder, global::ReplayKit.RPPreviewViewController previewViewController, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeAvailabilityObs => _didChangeAvailability; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::ReplayKit.RPScreenRecorder screenRecorder, global::ReplayKit.RPPreviewViewController previewViewController, global::Foundation.NSError error)> DidStopRecordingObs => _didStopRecording; + /// + public override void DidChangeAvailability(global::ReplayKit.RPScreenRecorder screenRecorder) => _didChangeAvailability.OnNext(screenRecorder); + /// + public override void DidStopRecording(global::ReplayKit.RPScreenRecorder screenRecorder, global::ReplayKit.RPPreviewViewController previewViewController, global::Foundation.NSError error) => _didStopRecording.OnNext((screenRecorder, previewViewController, error)); + } +} + +namespace SceneKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNAvoidOccluderConstraintDelegateRx : global::SceneKit.SCNAvoidOccluderConstraintDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNAvoidOccluderConstraint constraint, global::SceneKit.SCNNode occluder, global::SceneKit.SCNNode node)> _didAvoidOccluder = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNAvoidOccluderConstraint constraint, global::SceneKit.SCNNode occluder, global::SceneKit.SCNNode node)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNAvoidOccluderConstraint constraint, global::SceneKit.SCNNode occluder, global::SceneKit.SCNNode node)> DidAvoidOccluderObs => _didAvoidOccluder; + /// + public override void DidAvoidOccluder(global::SceneKit.SCNAvoidOccluderConstraint constraint, global::SceneKit.SCNNode occluder, global::SceneKit.SCNNode node) => _didAvoidOccluder.OnNext((constraint, occluder, node)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNCameraControllerDelegateRx : global::SceneKit.SCNCameraControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _cameraInertiaDidEnd = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _cameraInertiaWillStart = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable CameraInertiaDidEndObs => _cameraInertiaDidEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable CameraInertiaWillStartObs => _cameraInertiaWillStart; + /// + public override void CameraInertiaDidEnd(global::SceneKit.SCNCameraController cameraController) => _cameraInertiaDidEnd.OnNext(cameraController); + /// + public override void CameraInertiaWillStart(global::SceneKit.SCNCameraController cameraController) => _cameraInertiaWillStart.OnNext(cameraController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNNodeRendererDelegateRx : global::SceneKit.SCNNodeRendererDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNNode node, global::SceneKit.SCNRenderer renderer, global::Foundation.NSDictionary arguments)> _render = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNNode node, global::SceneKit.SCNRenderer renderer, global::Foundation.NSDictionary arguments)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNNode node, global::SceneKit.SCNRenderer renderer, global::Foundation.NSDictionary arguments)> RenderObs => _render; + /// + public override void Render(global::SceneKit.SCNNode node, global::SceneKit.SCNRenderer renderer, global::Foundation.NSDictionary arguments) => _render.OnNext((node, renderer, arguments)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNPhysicsContactDelegateRx : global::SceneKit.SCNPhysicsContactDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> _didBeginContact = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> _didEndContact = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> _didUpdateContact = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> DidBeginContactObs => _didBeginContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> DidEndContactObs => _didEndContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> DidUpdateContactObs => _didUpdateContact; + /// + public override void DidBeginContact(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact) => _didBeginContact.OnNext((world, contact)); + /// + public override void DidEndContact(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact) => _didEndContact.OnNext((world, contact)); + /// + public override void DidUpdateContact(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact) => _didUpdateContact.OnNext((world, contact)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNProgramDelegateRx : global::SceneKit.SCNProgramDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNProgram program, global::Foundation.NSError error)> _handleError = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNProgram program, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNProgram program, string symbol, uint location, uint programID, global::SceneKit.SCNRenderer renderer)> _unbindValue = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNProgram program, string symbol, uint location, uint programID, global::SceneKit.SCNRenderer renderer)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNProgram program, global::Foundation.NSError error)> HandleErrorObs => _handleError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNProgram program, string symbol, uint location, uint programID, global::SceneKit.SCNRenderer renderer)> UnbindValueObs => _unbindValue; + /// + public override void HandleError(global::SceneKit.SCNProgram program, global::Foundation.NSError error) => _handleError.OnNext((program, error)); + /// + public override void UnbindValue(global::SceneKit.SCNProgram program, string symbol, uint location, uint programID, global::SceneKit.SCNRenderer renderer) => _unbindValue.OnNext((program, symbol, location, programID, renderer)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNSceneRendererDelegateRx : global::SceneKit.SCNSceneRendererDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> _didApplyAnimations = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double atTime)> _didApplyConstraints = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double atTime)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> _didRenderScene = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> _didSimulatePhysics = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> _update = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> _willRenderScene = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> DidApplyAnimationsObs => _didApplyAnimations; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double atTime)> DidApplyConstraintsObs => _didApplyConstraints; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> DidRenderSceneObs => _didRenderScene; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> DidSimulatePhysicsObs => _didSimulatePhysics; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> UpdateObs => _update; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> WillRenderSceneObs => _willRenderScene; + /// + public override void DidApplyAnimations(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds) => _didApplyAnimations.OnNext((renderer, timeInSeconds)); + /// + public override void DidApplyConstraints(global::SceneKit.ISCNSceneRenderer renderer, double atTime) => _didApplyConstraints.OnNext((renderer, atTime)); + /// + public override void DidRenderScene(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds) => _didRenderScene.OnNext((renderer, scene, timeInSeconds)); + /// + public override void DidSimulatePhysics(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds) => _didSimulatePhysics.OnNext((renderer, timeInSeconds)); + /// + public override void Update(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds) => _update.OnNext((renderer, timeInSeconds)); + /// + public override void WillRenderScene(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds) => _willRenderScene.OnNext((renderer, scene, timeInSeconds)); + } +} + +namespace Speech +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class SFSpeechRecognitionTaskDelegateRx : global::Speech.SFSpeechRecognitionTaskDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didDetectSpeech = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFSpeechRecognitionResult recognitionResult)> _didFinishRecognition = new Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFSpeechRecognitionResult recognitionResult)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognitionTask task, bool successfully)> _didFinishSuccessfully = new Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognitionTask task, bool successfully)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFTranscription transcription)> _didHypothesizeTranscription = new Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFTranscription transcription)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _finishedReadingAudio = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _wasCancelled = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDetectSpeechObs => _didDetectSpeech; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFSpeechRecognitionResult recognitionResult)> DidFinishRecognitionObs => _didFinishRecognition; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Speech.SFSpeechRecognitionTask task, bool successfully)> DidFinishSuccessfullyObs => _didFinishSuccessfully; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFTranscription transcription)> DidHypothesizeTranscriptionObs => _didHypothesizeTranscription; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedReadingAudioObs => _finishedReadingAudio; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WasCancelledObs => _wasCancelled; + /// + public override void DidDetectSpeech(global::Speech.SFSpeechRecognitionTask task) => _didDetectSpeech.OnNext(task); + /// + public override void DidFinishRecognition(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFSpeechRecognitionResult recognitionResult) => _didFinishRecognition.OnNext((task, recognitionResult)); + /// + public override void DidFinishSuccessfully(global::Speech.SFSpeechRecognitionTask task, bool successfully) => _didFinishSuccessfully.OnNext((task, successfully)); + /// + public override void DidHypothesizeTranscription(global::Speech.SFSpeechRecognitionTask task, global::Speech.SFTranscription transcription) => _didHypothesizeTranscription.OnNext((task, transcription)); + /// + public override void FinishedReadingAudio(global::Speech.SFSpeechRecognitionTask task) => _finishedReadingAudio.OnNext(task); + /// + public override void WasCancelled(global::Speech.SFSpeechRecognitionTask task) => _wasCancelled.OnNext(task); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SFSpeechRecognizerDelegateRx : global::Speech.SFSpeechRecognizerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognizer speechRecognizer, bool available)> _availabilityDidChange = new Pharmacist.Common.SingleAwaitSubject<(global::Speech.SFSpeechRecognizer speechRecognizer, bool available)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Speech.SFSpeechRecognizer speechRecognizer, bool available)> AvailabilityDidChangeObs => _availabilityDidChange; + /// + public override void AvailabilityDidChange(global::Speech.SFSpeechRecognizer speechRecognizer, bool available) => _availabilityDidChange.OnNext((speechRecognizer, available)); + } +} + +namespace SpriteKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class SKPhysicsContactDelegateRx : global::SpriteKit.SKPhysicsContactDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBeginContact = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEndContact = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBeginContactObs => _didBeginContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndContactObs => _didEndContact; + /// + public override void DidBeginContact(global::SpriteKit.SKPhysicsContact contact) => _didBeginContact.OnNext(contact); + /// + public override void DidEndContact(global::SpriteKit.SKPhysicsContact contact) => _didEndContact.OnNext(contact); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SKSceneDelegateRx : global::SpriteKit.SKSceneDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didApplyConstraints = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEvaluateActions = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinishUpdate = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didSimulatePhysics = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(double currentTime, global::SpriteKit.SKScene scene)> _update = new Pharmacist.Common.SingleAwaitSubject<(double currentTime, global::SpriteKit.SKScene scene)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidApplyConstraintsObs => _didApplyConstraints; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEvaluateActionsObs => _didEvaluateActions; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishUpdateObs => _didFinishUpdate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidSimulatePhysicsObs => _didSimulatePhysics; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(double currentTime, global::SpriteKit.SKScene scene)> UpdateObs => _update; + /// + public override void DidApplyConstraints(global::SpriteKit.SKScene scene) => _didApplyConstraints.OnNext(scene); + /// + public override void DidEvaluateActions(global::SpriteKit.SKScene scene) => _didEvaluateActions.OnNext(scene); + /// + public override void DidFinishUpdate(global::SpriteKit.SKScene scene) => _didFinishUpdate.OnNext(scene); + /// + public override void DidSimulatePhysics(global::SpriteKit.SKScene scene) => _didSimulatePhysics.OnNext(scene); + /// + public override void Update(double currentTime, global::SpriteKit.SKScene scene) => _update.OnNext((currentTime, scene)); + } +} + +namespace StoreKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class SKProductsRequestDelegateRx : global::StoreKit.SKProductsRequestDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKProductsRequest request, global::StoreKit.SKProductsResponse response)> _receivedResponse = new Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKProductsRequest request, global::StoreKit.SKProductsResponse response)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::StoreKit.SKProductsRequest request, global::StoreKit.SKProductsResponse response)> ReceivedResponseObs => _receivedResponse; + /// + public override void ReceivedResponse(global::StoreKit.SKProductsRequest request, global::StoreKit.SKProductsResponse response) => _receivedResponse.OnNext((request, response)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SKRequestDelegateRx : global::StoreKit.SKRequestDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKRequest request, global::Foundation.NSError error)> _requestFailed = new Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKRequest request, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _requestFinished = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::StoreKit.SKRequest request, global::Foundation.NSError error)> RequestFailedObs => _requestFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable RequestFinishedObs => _requestFinished; + /// + public override void RequestFailed(global::StoreKit.SKRequest request, global::Foundation.NSError error) => _requestFailed.OnNext((request, error)); + /// + public override void RequestFinished(global::StoreKit.SKRequest request) => _requestFinished.OnNext(request); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SKStoreProductViewControllerDelegateRx : global::StoreKit.SKStoreProductViewControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _finished = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedObs => _finished; + /// + public override void Finished(global::StoreKit.SKStoreProductViewController controller) => _finished.OnNext(controller); + } +} + +namespace UserNotifications +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class UNUserNotificationCenterDelegateRx : global::UserNotifications.UNUserNotificationCenterDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotificationResponse response, global::System.Action completionHandler)> _didReceiveNotificationResponse = new Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotificationResponse response, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification)> _openSettings = new Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification, global::System.Action completionHandler)> _willPresentNotification = new Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotificationResponse response, global::System.Action completionHandler)> DidReceiveNotificationResponseObs => _didReceiveNotificationResponse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification)> OpenSettingsObs => _openSettings; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification, global::System.Action completionHandler)> WillPresentNotificationObs => _willPresentNotification; + /// + public override void DidReceiveNotificationResponse(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotificationResponse response, global::System.Action completionHandler) => _didReceiveNotificationResponse.OnNext((center, response, completionHandler)); + /// + public override void OpenSettings(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification) => _openSettings.OnNext((center, notification)); + /// + public override void WillPresentNotification(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification, global::System.Action completionHandler) => _willPresentNotification.OnNext((center, notification, completionHandler)); + } +} + +namespace VideoSubscriberAccount +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class VSAccountManagerDelegateRx : global::VideoSubscriberAccount.VSAccountManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::VideoSubscriberAccount.VSAccountManager accountManager, global::AppKit.NSViewController viewController)> _dismissViewController = new Pharmacist.Common.SingleAwaitSubject<(global::VideoSubscriberAccount.VSAccountManager accountManager, global::AppKit.NSViewController viewController)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::VideoSubscriberAccount.VSAccountManager accountManager, global::AppKit.NSViewController viewController)> _presentViewController = new Pharmacist.Common.SingleAwaitSubject<(global::VideoSubscriberAccount.VSAccountManager accountManager, global::AppKit.NSViewController viewController)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::VideoSubscriberAccount.VSAccountManager accountManager, global::AppKit.NSViewController viewController)> DismissViewControllerObs => _dismissViewController; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::VideoSubscriberAccount.VSAccountManager accountManager, global::AppKit.NSViewController viewController)> PresentViewControllerObs => _presentViewController; + /// + public override void DismissViewController(global::VideoSubscriberAccount.VSAccountManager accountManager, global::AppKit.NSViewController viewController) => _dismissViewController.OnNext((accountManager, viewController)); + /// + public override void PresentViewController(global::VideoSubscriberAccount.VSAccountManager accountManager, global::AppKit.NSViewController viewController) => _presentViewController.OnNext((accountManager, viewController)); + } +} + +namespace WebKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class WebFrameLoadDelegateRx : global::WebKit.WebFrameLoadDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)> _canceledClientRedirect = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)> _changedLocationWithinPage = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::WebKit.WebScriptObject windowObject, global::WebKit.WebFrame forFrame)> _clearedWindowObject = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::WebKit.WebScriptObject windowObject, global::WebKit.WebFrame forFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)> _commitedLoad = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::JavaScriptCore.JSContext context, global::WebKit.WebFrame frame)> _didCreateJavaScriptContext = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::JavaScriptCore.JSContext context, global::WebKit.WebFrame frame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSError error, global::WebKit.WebFrame forFrame)> _failedLoadWithError = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSError error, global::WebKit.WebFrame forFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSError error, global::WebKit.WebFrame forFrame)> _failedProvisionalLoad = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSError error, global::WebKit.WebFrame forFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)> _finishedLoad = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::AppKit.NSImage image, global::WebKit.WebFrame forFrame)> _receivedIcon = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::AppKit.NSImage image, global::WebKit.WebFrame forFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)> _receivedServerRedirectForProvisionalLoad = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, string title, global::WebKit.WebFrame forFrame)> _receivedTitle = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, string title, global::WebKit.WebFrame forFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)> _startedProvisionalLoad = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)> _willCloseFrame = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSUrl toUrl, double secondsDelay, global::Foundation.NSDate fireDate, global::WebKit.WebFrame forFrame)> _willPerformClientRedirect = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSUrl toUrl, double secondsDelay, global::Foundation.NSDate fireDate, global::WebKit.WebFrame forFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::WebKit.WebScriptObject windowScriptObject)> _windowScriptObjectAvailable = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::WebKit.WebScriptObject windowScriptObject)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)> CanceledClientRedirectObs => _canceledClientRedirect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)> ChangedLocationWithinPageObs => _changedLocationWithinPage; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView webView, global::WebKit.WebScriptObject windowObject, global::WebKit.WebFrame forFrame)> ClearedWindowObjectObs => _clearedWindowObject; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)> CommitedLoadObs => _commitedLoad; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView webView, global::JavaScriptCore.JSContext context, global::WebKit.WebFrame frame)> DidCreateJavaScriptContextObs => _didCreateJavaScriptContext; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::Foundation.NSError error, global::WebKit.WebFrame forFrame)> FailedLoadWithErrorObs => _failedLoadWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::Foundation.NSError error, global::WebKit.WebFrame forFrame)> FailedProvisionalLoadObs => _failedProvisionalLoad; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)> FinishedLoadObs => _finishedLoad; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::AppKit.NSImage image, global::WebKit.WebFrame forFrame)> ReceivedIconObs => _receivedIcon; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)> ReceivedServerRedirectForProvisionalLoadObs => _receivedServerRedirectForProvisionalLoad; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, string title, global::WebKit.WebFrame forFrame)> ReceivedTitleObs => _receivedTitle; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)> StartedProvisionalLoadObs => _startedProvisionalLoad; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame)> WillCloseFrameObs => _willCloseFrame; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::Foundation.NSUrl toUrl, double secondsDelay, global::Foundation.NSDate fireDate, global::WebKit.WebFrame forFrame)> WillPerformClientRedirectObs => _willPerformClientRedirect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView webView, global::WebKit.WebScriptObject windowScriptObject)> WindowScriptObjectAvailableObs => _windowScriptObjectAvailable; + /// + public override void CanceledClientRedirect(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame) => _canceledClientRedirect.OnNext((sender, forFrame)); + /// + public override void ChangedLocationWithinPage(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame) => _changedLocationWithinPage.OnNext((sender, forFrame)); + /// + public override void ClearedWindowObject(global::WebKit.WebView webView, global::WebKit.WebScriptObject windowObject, global::WebKit.WebFrame forFrame) => _clearedWindowObject.OnNext((webView, windowObject, forFrame)); + /// + public override void CommitedLoad(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame) => _commitedLoad.OnNext((sender, forFrame)); + /// + public override void DidCreateJavaScriptContext(global::WebKit.WebView webView, global::JavaScriptCore.JSContext context, global::WebKit.WebFrame frame) => _didCreateJavaScriptContext.OnNext((webView, context, frame)); + /// + public override void FailedLoadWithError(global::WebKit.WebView sender, global::Foundation.NSError error, global::WebKit.WebFrame forFrame) => _failedLoadWithError.OnNext((sender, error, forFrame)); + /// + public override void FailedProvisionalLoad(global::WebKit.WebView sender, global::Foundation.NSError error, global::WebKit.WebFrame forFrame) => _failedProvisionalLoad.OnNext((sender, error, forFrame)); + /// + public override void FinishedLoad(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame) => _finishedLoad.OnNext((sender, forFrame)); + /// + public override void ReceivedIcon(global::WebKit.WebView sender, global::AppKit.NSImage image, global::WebKit.WebFrame forFrame) => _receivedIcon.OnNext((sender, image, forFrame)); + /// + public override void ReceivedServerRedirectForProvisionalLoad(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame) => _receivedServerRedirectForProvisionalLoad.OnNext((sender, forFrame)); + /// + public override void ReceivedTitle(global::WebKit.WebView sender, string title, global::WebKit.WebFrame forFrame) => _receivedTitle.OnNext((sender, title, forFrame)); + /// + public override void StartedProvisionalLoad(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame) => _startedProvisionalLoad.OnNext((sender, forFrame)); + /// + public override void WillCloseFrame(global::WebKit.WebView sender, global::WebKit.WebFrame forFrame) => _willCloseFrame.OnNext((sender, forFrame)); + /// + public override void WillPerformClientRedirect(global::WebKit.WebView sender, global::Foundation.NSUrl toUrl, double secondsDelay, global::Foundation.NSDate fireDate, global::WebKit.WebFrame forFrame) => _willPerformClientRedirect.OnNext((sender, toUrl, secondsDelay, fireDate, forFrame)); + /// + public override void WindowScriptObjectAvailable(global::WebKit.WebView webView, global::WebKit.WebScriptObject windowScriptObject) => _windowScriptObjectAvailable.OnNext((webView, windowScriptObject)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class WebPolicyDelegateRx : global::WebKit.WebPolicyDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, string mimeType, global::Foundation.NSUrlRequest request, global::WebKit.WebFrame frame, global::Foundation.NSObject decisionToken)> _decidePolicyForMimeType = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, string mimeType, global::Foundation.NSUrlRequest request, global::WebKit.WebFrame frame, global::Foundation.NSObject decisionToken)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::Foundation.NSDictionary actionInformation, global::Foundation.NSUrlRequest request, global::WebKit.WebFrame frame, global::Foundation.NSObject decisionToken)> _decidePolicyForNavigation = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::Foundation.NSDictionary actionInformation, global::Foundation.NSUrlRequest request, global::WebKit.WebFrame frame, global::Foundation.NSObject decisionToken)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::Foundation.NSDictionary actionInformation, global::Foundation.NSUrlRequest request, string newFrameName, global::Foundation.NSObject decisionToken)> _decidePolicyForNewWindow = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::Foundation.NSDictionary actionInformation, global::Foundation.NSUrlRequest request, string newFrameName, global::Foundation.NSObject decisionToken)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::Foundation.NSError error, global::WebKit.WebFrame frame)> _unableToImplementPolicy = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::Foundation.NSError error, global::WebKit.WebFrame frame)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView webView, string mimeType, global::Foundation.NSUrlRequest request, global::WebKit.WebFrame frame, global::Foundation.NSObject decisionToken)> DecidePolicyForMimeTypeObs => _decidePolicyForMimeType; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView webView, global::Foundation.NSDictionary actionInformation, global::Foundation.NSUrlRequest request, global::WebKit.WebFrame frame, global::Foundation.NSObject decisionToken)> DecidePolicyForNavigationObs => _decidePolicyForNavigation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView webView, global::Foundation.NSDictionary actionInformation, global::Foundation.NSUrlRequest request, string newFrameName, global::Foundation.NSObject decisionToken)> DecidePolicyForNewWindowObs => _decidePolicyForNewWindow; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView webView, global::Foundation.NSError error, global::WebKit.WebFrame frame)> UnableToImplementPolicyObs => _unableToImplementPolicy; + /// + public override void DecidePolicyForMimeType(global::WebKit.WebView webView, string mimeType, global::Foundation.NSUrlRequest request, global::WebKit.WebFrame frame, global::Foundation.NSObject decisionToken) => _decidePolicyForMimeType.OnNext((webView, mimeType, request, frame, decisionToken)); + /// + public override void DecidePolicyForNavigation(global::WebKit.WebView webView, global::Foundation.NSDictionary actionInformation, global::Foundation.NSUrlRequest request, global::WebKit.WebFrame frame, global::Foundation.NSObject decisionToken) => _decidePolicyForNavigation.OnNext((webView, actionInformation, request, frame, decisionToken)); + /// + public override void DecidePolicyForNewWindow(global::WebKit.WebView webView, global::Foundation.NSDictionary actionInformation, global::Foundation.NSUrlRequest request, string newFrameName, global::Foundation.NSObject decisionToken) => _decidePolicyForNewWindow.OnNext((webView, actionInformation, request, newFrameName, decisionToken)); + /// + public override void UnableToImplementPolicy(global::WebKit.WebView webView, global::Foundation.NSError error, global::WebKit.WebFrame frame) => _unableToImplementPolicy.OnNext((webView, error, frame)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class WebResourceLoadDelegateRx : global::WebKit.WebResourceLoadDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSUrlAuthenticationChallenge challenge, global::WebKit.WebDataSource dataSource)> _onCancelledAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSUrlAuthenticationChallenge challenge, global::WebKit.WebDataSource dataSource)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSError withError, global::WebKit.WebDataSource dataSource)> _onFailedLoading = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSError withError, global::WebKit.WebDataSource dataSource)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::WebKit.WebDataSource dataSource)> _onFinishedLoading = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::WebKit.WebDataSource dataSource)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSError error, global::WebKit.WebDataSource dataSource)> _onPlugInFailed = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSError error, global::WebKit.WebDataSource dataSource)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSUrlAuthenticationChallenge challenge, global::WebKit.WebDataSource dataSource)> _onReceivedAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSUrlAuthenticationChallenge challenge, global::WebKit.WebDataSource dataSource)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::System.nint length, global::WebKit.WebDataSource dataSource)> _onReceivedContentLength = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::System.nint length, global::WebKit.WebDataSource dataSource)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSUrlResponse responseReceived, global::WebKit.WebDataSource dataSource)> _onReceivedResponse = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSUrlResponse responseReceived, global::WebKit.WebDataSource dataSource)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSUrlAuthenticationChallenge challenge, global::WebKit.WebDataSource dataSource)> OnCancelledAuthenticationChallengeObs => _onCancelledAuthenticationChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSError withError, global::WebKit.WebDataSource dataSource)> OnFailedLoadingObs => _onFailedLoading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::WebKit.WebDataSource dataSource)> OnFinishedLoadingObs => _onFinishedLoading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::Foundation.NSError error, global::WebKit.WebDataSource dataSource)> OnPlugInFailedObs => _onPlugInFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSUrlAuthenticationChallenge challenge, global::WebKit.WebDataSource dataSource)> OnReceivedAuthenticationChallengeObs => _onReceivedAuthenticationChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::System.nint length, global::WebKit.WebDataSource dataSource)> OnReceivedContentLengthObs => _onReceivedContentLength; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSUrlResponse responseReceived, global::WebKit.WebDataSource dataSource)> OnReceivedResponseObs => _onReceivedResponse; + /// + public override void OnCancelledAuthenticationChallenge(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSUrlAuthenticationChallenge challenge, global::WebKit.WebDataSource dataSource) => _onCancelledAuthenticationChallenge.OnNext((sender, identifier, challenge, dataSource)); + /// + public override void OnFailedLoading(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSError withError, global::WebKit.WebDataSource dataSource) => _onFailedLoading.OnNext((sender, identifier, withError, dataSource)); + /// + public override void OnFinishedLoading(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::WebKit.WebDataSource dataSource) => _onFinishedLoading.OnNext((sender, identifier, dataSource)); + /// + public override void OnPlugInFailed(global::WebKit.WebView sender, global::Foundation.NSError error, global::WebKit.WebDataSource dataSource) => _onPlugInFailed.OnNext((sender, error, dataSource)); + /// + public override void OnReceivedAuthenticationChallenge(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSUrlAuthenticationChallenge challenge, global::WebKit.WebDataSource dataSource) => _onReceivedAuthenticationChallenge.OnNext((sender, identifier, challenge, dataSource)); + /// + public override void OnReceivedContentLength(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::System.nint length, global::WebKit.WebDataSource dataSource) => _onReceivedContentLength.OnNext((sender, identifier, length, dataSource)); + /// + public override void OnReceivedResponse(global::WebKit.WebView sender, global::Foundation.NSObject identifier, global::Foundation.NSUrlResponse responseReceived, global::WebKit.WebDataSource dataSource) => _onReceivedResponse.OnNext((sender, identifier, responseReceived, dataSource)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class WebUIDelegateRx : global::WebKit.WebUIDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _uIClose = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::CoreGraphics.CGRect rect)> _uIDrawFooterInRect = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::CoreGraphics.CGRect rect)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::CoreGraphics.CGRect rect)> _uIDrawHeaderInRect = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::CoreGraphics.CGRect rect)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _uIFocus = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::AppKit.NSResponder newResponder)> _uIMakeFirstResponder = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::AppKit.NSResponder newResponder)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSDictionary elementInformation, global::AppKit.NSEventModifierMask modifierFlags)> _uIMouseDidMoveOverElement = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::Foundation.NSDictionary elementInformation, global::AppKit.NSEventModifierMask modifierFlags)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrameView frameView)> _uIPrintFrameView = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.WebFrameView frameView)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, string message)> _uIRunJavaScriptAlertPanel = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, string message)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, string withMessage, global::WebKit.WebFrame initiatedByFrame)> _uIRunJavaScriptAlertPanelMessage = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, string withMessage, global::WebKit.WebFrame initiatedByFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _uIRunModal = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.IWebOpenPanelResultListener resultListener)> _uIRunOpenPanelForFileButton = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::WebKit.IWebOpenPanelResultListener resultListener)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::CoreGraphics.CGRect frame)> _uISetContentRect = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::CoreGraphics.CGRect frame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::CoreGraphics.CGRect newFrame)> _uISetFrame = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, global::CoreGraphics.CGRect newFrame)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, bool resizable)> _uISetResizable = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, bool resizable)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, bool visible)> _uISetStatusBarVisible = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, bool visible)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, string text)> _uISetStatusText = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, string text)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, bool visible)> _uISetToolbarsVisible = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView sender, bool visible)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _uIShow = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _uIUnfocus = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::WebKit.WebDragDestinationAction action, global::AppKit.NSDraggingInfo draggingInfo)> _uIWillPerformDragDestination = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::WebKit.WebDragDestinationAction action, global::AppKit.NSDraggingInfo draggingInfo)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::WebKit.WebDragSourceAction action, global::CoreGraphics.CGPoint sourcePoint, global::AppKit.NSPasteboard pasteboard)> _uIWillPerformDragSource = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WebView webView, global::WebKit.WebDragSourceAction action, global::CoreGraphics.CGPoint sourcePoint, global::AppKit.NSPasteboard pasteboard)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UICloseObs => _uIClose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::CoreGraphics.CGRect rect)> UIDrawFooterInRectObs => _uIDrawFooterInRect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::CoreGraphics.CGRect rect)> UIDrawHeaderInRectObs => _uIDrawHeaderInRect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UIFocusObs => _uIFocus; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::AppKit.NSResponder newResponder)> UIMakeFirstResponderObs => _uIMakeFirstResponder; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::Foundation.NSDictionary elementInformation, global::AppKit.NSEventModifierMask modifierFlags)> UIMouseDidMoveOverElementObs => _uIMouseDidMoveOverElement; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::WebKit.WebFrameView frameView)> UIPrintFrameViewObs => _uIPrintFrameView; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, string message)> UIRunJavaScriptAlertPanelObs => _uIRunJavaScriptAlertPanel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, string withMessage, global::WebKit.WebFrame initiatedByFrame)> UIRunJavaScriptAlertPanelMessageObs => _uIRunJavaScriptAlertPanelMessage; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UIRunModalObs => _uIRunModal; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::WebKit.IWebOpenPanelResultListener resultListener)> UIRunOpenPanelForFileButtonObs => _uIRunOpenPanelForFileButton; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::CoreGraphics.CGRect frame)> UISetContentRectObs => _uISetContentRect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, global::CoreGraphics.CGRect newFrame)> UISetFrameObs => _uISetFrame; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, bool resizable)> UISetResizableObs => _uISetResizable; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, bool visible)> UISetStatusBarVisibleObs => _uISetStatusBarVisible; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, string text)> UISetStatusTextObs => _uISetStatusText; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView sender, bool visible)> UISetToolbarsVisibleObs => _uISetToolbarsVisible; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UIShowObs => _uIShow; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UIUnfocusObs => _uIUnfocus; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView webView, global::WebKit.WebDragDestinationAction action, global::AppKit.NSDraggingInfo draggingInfo)> UIWillPerformDragDestinationObs => _uIWillPerformDragDestination; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WebView webView, global::WebKit.WebDragSourceAction action, global::CoreGraphics.CGPoint sourcePoint, global::AppKit.NSPasteboard pasteboard)> UIWillPerformDragSourceObs => _uIWillPerformDragSource; + /// + public override void UIClose(global::WebKit.WebView sender) => _uIClose.OnNext(sender); + /// + public override void UIDrawFooterInRect(global::WebKit.WebView sender, global::CoreGraphics.CGRect rect) => _uIDrawFooterInRect.OnNext((sender, rect)); + /// + public override void UIDrawHeaderInRect(global::WebKit.WebView sender, global::CoreGraphics.CGRect rect) => _uIDrawHeaderInRect.OnNext((sender, rect)); + /// + public override void UIFocus(global::WebKit.WebView sender) => _uIFocus.OnNext(sender); + /// + public override void UIMakeFirstResponder(global::WebKit.WebView sender, global::AppKit.NSResponder newResponder) => _uIMakeFirstResponder.OnNext((sender, newResponder)); + /// + public override void UIMouseDidMoveOverElement(global::WebKit.WebView sender, global::Foundation.NSDictionary elementInformation, global::AppKit.NSEventModifierMask modifierFlags) => _uIMouseDidMoveOverElement.OnNext((sender, elementInformation, modifierFlags)); + /// + public override void UIPrintFrameView(global::WebKit.WebView sender, global::WebKit.WebFrameView frameView) => _uIPrintFrameView.OnNext((sender, frameView)); + /// + public override void UIRunJavaScriptAlertPanel(global::WebKit.WebView sender, string message) => _uIRunJavaScriptAlertPanel.OnNext((sender, message)); + /// + public override void UIRunJavaScriptAlertPanelMessage(global::WebKit.WebView sender, string withMessage, global::WebKit.WebFrame initiatedByFrame) => _uIRunJavaScriptAlertPanelMessage.OnNext((sender, withMessage, initiatedByFrame)); + /// + public override void UIRunModal(global::WebKit.WebView sender) => _uIRunModal.OnNext(sender); + /// + public override void UIRunOpenPanelForFileButton(global::WebKit.WebView sender, global::WebKit.IWebOpenPanelResultListener resultListener) => _uIRunOpenPanelForFileButton.OnNext((sender, resultListener)); + /// + public override void UISetContentRect(global::WebKit.WebView sender, global::CoreGraphics.CGRect frame) => _uISetContentRect.OnNext((sender, frame)); + /// + public override void UISetFrame(global::WebKit.WebView sender, global::CoreGraphics.CGRect newFrame) => _uISetFrame.OnNext((sender, newFrame)); + /// + public override void UISetResizable(global::WebKit.WebView sender, bool resizable) => _uISetResizable.OnNext((sender, resizable)); + /// + public override void UISetStatusBarVisible(global::WebKit.WebView sender, bool visible) => _uISetStatusBarVisible.OnNext((sender, visible)); + /// + public override void UISetStatusText(global::WebKit.WebView sender, string text) => _uISetStatusText.OnNext((sender, text)); + /// + public override void UISetToolbarsVisible(global::WebKit.WebView sender, bool visible) => _uISetToolbarsVisible.OnNext((sender, visible)); + /// + public override void UIShow(global::WebKit.WebView sender) => _uIShow.OnNext(sender); + /// + public override void UIUnfocus(global::WebKit.WebView sender) => _uIUnfocus.OnNext(sender); + /// + public override void UIWillPerformDragDestination(global::WebKit.WebView webView, global::WebKit.WebDragDestinationAction action, global::AppKit.NSDraggingInfo draggingInfo) => _uIWillPerformDragDestination.OnNext((webView, action, draggingInfo)); + /// + public override void UIWillPerformDragSource(global::WebKit.WebView webView, global::WebKit.WebDragSourceAction action, global::CoreGraphics.CGPoint sourcePoint, global::AppKit.NSPasteboard pasteboard) => _uIWillPerformDragSource.OnNext((webView, action, sourcePoint, pasteboard)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class WKNavigationDelegateRx : global::WebKit.WKNavigationDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _contentProcessDidTerminate = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigationAction navigationAction, global::WebKit.WKWebpagePreferences preferences, global::System.Action decisionHandler)> _decidePolicy = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigationAction navigationAction, global::WebKit.WKWebpagePreferences preferences, global::System.Action decisionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> _didCommitNavigation = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error)> _didFailNavigation = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error)> _didFailProvisionalNavigation = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> _didFinishNavigation = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> _didReceiveAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> _didReceiveServerRedirectForProvisionalNavigation = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> _didStartProvisionalNavigation = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action decisionHandler)> _shouldAllowDeprecatedTls = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action decisionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ContentProcessDidTerminateObs => _contentProcessDidTerminate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKNavigationAction navigationAction, global::WebKit.WKWebpagePreferences preferences, global::System.Action decisionHandler)> DecidePolicyObs => _decidePolicy; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> DidCommitNavigationObs => _didCommitNavigation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error)> DidFailNavigationObs => _didFailNavigation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error)> DidFailProvisionalNavigationObs => _didFailProvisionalNavigation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> DidFinishNavigationObs => _didFinishNavigation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> DidReceiveAuthenticationChallengeObs => _didReceiveAuthenticationChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> DidReceiveServerRedirectForProvisionalNavigationObs => _didReceiveServerRedirectForProvisionalNavigation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation)> DidStartProvisionalNavigationObs => _didStartProvisionalNavigation; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action decisionHandler)> ShouldAllowDeprecatedTlsObs => _shouldAllowDeprecatedTls; + /// + public override void ContentProcessDidTerminate(global::WebKit.WKWebView webView) => _contentProcessDidTerminate.OnNext(webView); + /// + public override void DecidePolicy(global::WebKit.WKWebView webView, global::WebKit.WKNavigationAction navigationAction, global::WebKit.WKWebpagePreferences preferences, global::System.Action decisionHandler) => _decidePolicy.OnNext((webView, navigationAction, preferences, decisionHandler)); + /// + public override void DidCommitNavigation(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation) => _didCommitNavigation.OnNext((webView, navigation)); + /// + public override void DidFailNavigation(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error) => _didFailNavigation.OnNext((webView, navigation, error)); + /// + public override void DidFailProvisionalNavigation(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation, global::Foundation.NSError error) => _didFailProvisionalNavigation.OnNext((webView, navigation, error)); + /// + public override void DidFinishNavigation(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation) => _didFinishNavigation.OnNext((webView, navigation)); + /// + public override void DidReceiveAuthenticationChallenge(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler) => _didReceiveAuthenticationChallenge.OnNext((webView, challenge, completionHandler)); + /// + public override void DidReceiveServerRedirectForProvisionalNavigation(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation) => _didReceiveServerRedirectForProvisionalNavigation.OnNext((webView, navigation)); + /// + public override void DidStartProvisionalNavigation(global::WebKit.WKWebView webView, global::WebKit.WKNavigation navigation) => _didStartProvisionalNavigation.OnNext((webView, navigation)); + /// + public override void ShouldAllowDeprecatedTls(global::WebKit.WKWebView webView, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action decisionHandler) => _shouldAllowDeprecatedTls.OnNext((webView, challenge, decisionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class WKUIDelegateRx : global::WebKit.WKUIDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didClose = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)> _runJavaScriptAlertPanel = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)> _runJavaScriptConfirmPanel = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, string prompt, string defaultText, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)> _runJavaScriptTextInputPanel = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, string prompt, string defaultText, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKOpenPanelParameters parameters, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)> _runOpenPanel = new Pharmacist.Common.SingleAwaitSubject<(global::WebKit.WKWebView webView, global::WebKit.WKOpenPanelParameters parameters, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidCloseObs => _didClose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)> RunJavaScriptAlertPanelObs => _runJavaScriptAlertPanel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)> RunJavaScriptConfirmPanelObs => _runJavaScriptConfirmPanel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, string prompt, string defaultText, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)> RunJavaScriptTextInputPanelObs => _runJavaScriptTextInputPanel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WebKit.WKWebView webView, global::WebKit.WKOpenPanelParameters parameters, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler)> RunOpenPanelObs => _runOpenPanel; + /// + public override void DidClose(global::WebKit.WKWebView webView) => _didClose.OnNext(webView); + /// + public override void RunJavaScriptAlertPanel(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler) => _runJavaScriptAlertPanel.OnNext((webView, message, frame, completionHandler)); + /// + public override void RunJavaScriptConfirmPanel(global::WebKit.WKWebView webView, string message, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler) => _runJavaScriptConfirmPanel.OnNext((webView, message, frame, completionHandler)); + /// + public override void RunJavaScriptTextInputPanel(global::WebKit.WKWebView webView, string prompt, string defaultText, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler) => _runJavaScriptTextInputPanel.OnNext((webView, prompt, defaultText, frame, completionHandler)); + /// + public override void RunOpenPanel(global::WebKit.WKWebView webView, global::WebKit.WKOpenPanelParameters parameters, global::WebKit.WKFrameInfo frame, global::System.Action completionHandler) => _runOpenPanel.OnNext((webView, parameters, frame, completionHandler)); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/xamarin.watchos10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/xamarin.watchos10.approved.txt new file mode 100644 index 0000000..9299d8b --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Platforms/xamarin.watchos10.approved.txt @@ -0,0 +1,3662 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace AVFoundation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxAVSpeechSynthesizerEvents Events(this global::AVFoundation.AVSpeechSynthesizer item) => new RxAVSpeechSynthesizerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxAVSpeechSynthesizerEvents + { + private readonly global::AVFoundation.AVSpeechSynthesizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxAVSpeechSynthesizerEvents(global::AVFoundation.AVSpeechSynthesizer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidCancelSpeechUtterance => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidCancelSpeechUtterance += x, x => _data.DidCancelSpeechUtterance -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidContinueSpeechUtterance => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidContinueSpeechUtterance += x, x => _data.DidContinueSpeechUtterance -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidFinishSpeechUtterance => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidFinishSpeechUtterance += x, x => _data.DidFinishSpeechUtterance -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidPauseSpeechUtterance => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidPauseSpeechUtterance += x, x => _data.DidPauseSpeechUtterance -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidStartSpeechUtterance => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerUteranceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidStartSpeechUtterance += x, x => _data.DidStartSpeechUtterance -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillSpeakRangeOfSpeechString => global::System.Reactive.Linq.Observable.FromEvent, global::AVFoundation.AVSpeechSynthesizerWillSpeakEventArgs>(eventHandler => + { + void Handler(object sender, global::AVFoundation.AVSpeechSynthesizerWillSpeakEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillSpeakRangeOfSpeechString += x, x => _data.WillSpeakRangeOfSpeechString -= x); + } +} + +namespace CoreBluetooth +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCBCentralManagerEvents Events(this global::CoreBluetooth.CBCentralManager item) => new RxCBCentralManagerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCBPeripheralEvents Events(this global::CoreBluetooth.CBPeripheral item) => new RxCBPeripheralEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCBPeripheralManagerEvents Events(this global::CoreBluetooth.CBPeripheralManager item) => new RxCBPeripheralManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCBCentralManagerEvents + { + private readonly global::CoreBluetooth.CBCentralManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCBCentralManagerEvents(global::CoreBluetooth.CBCentralManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ConnectedPeripheral => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ConnectedPeripheral += x, x => _data.ConnectedPeripheral -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ConnectionEventDidOccur => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralConnectionEventEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralConnectionEventEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ConnectionEventDidOccur += x, x => _data.ConnectionEventDidOccur -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateAncsAuthorization => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBAncsAuthorizationUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBAncsAuthorizationUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateAncsAuthorization += x, x => _data.DidUpdateAncsAuthorization -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DisconnectedPeripheral => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DisconnectedPeripheral += x, x => _data.DisconnectedPeripheral -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DiscoveredPeripheral => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBDiscoveredPeripheralEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBDiscoveredPeripheralEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DiscoveredPeripheral += x, x => _data.DiscoveredPeripheral -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable FailedToConnectPeripheral => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.FailedToConnectPeripheral += x, x => _data.FailedToConnectPeripheral -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedState => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedState += x, x => _data.UpdatedState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillRestoreState => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBWillRestoreEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBWillRestoreEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillRestoreState += x, x => _data.WillRestoreState -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCBPeripheralEvents + { + private readonly global::CoreBluetooth.CBPeripheral _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCBPeripheralEvents(global::CoreBluetooth.CBPeripheral data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidOpenL2CapChannel => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralOpenL2CapChannelEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralOpenL2CapChannelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidOpenL2CapChannel += x, x => _data.DidOpenL2CapChannel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DiscoveredCharacteristic => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBServiceEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBServiceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DiscoveredCharacteristic += x, x => _data.DiscoveredCharacteristic -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DiscoveredDescriptor => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBCharacteristicEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBCharacteristicEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DiscoveredDescriptor += x, x => _data.DiscoveredDescriptor -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DiscoveredIncludedService => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBServiceEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBServiceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DiscoveredIncludedService += x, x => _data.DiscoveredIncludedService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DiscoveredService => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DiscoveredService += x, x => _data.DiscoveredService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsReadyToSendWriteWithoutResponse => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsReadyToSendWriteWithoutResponse += x, x => _data.IsReadyToSendWriteWithoutResponse -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ModifiedServices => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralServicesEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralServicesEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ModifiedServices += x, x => _data.ModifiedServices -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RssiRead => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBRssiEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBRssiEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RssiRead += x, x => _data.RssiRead -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RssiUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RssiUpdated += x, x => _data.RssiUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedCharacterteristicValue => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBCharacteristicEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBCharacteristicEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedCharacterteristicValue += x, x => _data.UpdatedCharacterteristicValue -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedName => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedName += x, x => _data.UpdatedName -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedNotificationState => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBCharacteristicEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBCharacteristicEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedNotificationState += x, x => _data.UpdatedNotificationState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedValue => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBDescriptorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBDescriptorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedValue += x, x => _data.UpdatedValue -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WroteCharacteristicValue => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBCharacteristicEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBCharacteristicEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WroteCharacteristicValue += x, x => _data.WroteCharacteristicValue -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WroteDescriptorValue => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBDescriptorEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBDescriptorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WroteDescriptorValue += x, x => _data.WroteDescriptorValue -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCBPeripheralManagerEvents + { + private readonly global::CoreBluetooth.CBPeripheralManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCBPeripheralManagerEvents(global::CoreBluetooth.CBPeripheralManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AdvertisingStarted => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AdvertisingStarted += x, x => _data.AdvertisingStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CharacteristicSubscribed => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerSubscriptionEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerSubscriptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CharacteristicSubscribed += x, x => _data.CharacteristicSubscribed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CharacteristicUnsubscribed => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerSubscriptionEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerSubscriptionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CharacteristicUnsubscribed += x, x => _data.CharacteristicUnsubscribed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidOpenL2CapChannel => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerOpenL2CapChannelEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerOpenL2CapChannelEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidOpenL2CapChannel += x, x => _data.DidOpenL2CapChannel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidPublishL2CapChannel => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerL2CapChannelOperationEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerL2CapChannelOperationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidPublishL2CapChannel += x, x => _data.DidPublishL2CapChannel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUnpublishL2CapChannel => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerL2CapChannelOperationEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerL2CapChannelOperationEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUnpublishL2CapChannel += x, x => _data.DidUnpublishL2CapChannel -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadRequestReceived => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBATTRequestEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBATTRequestEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadRequestReceived += x, x => _data.ReadRequestReceived -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadyToUpdateSubscribers => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadyToUpdateSubscribers += x, x => _data.ReadyToUpdateSubscribers -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ServiceAdded => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBPeripheralManagerServiceEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBPeripheralManagerServiceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ServiceAdded += x, x => _data.ServiceAdded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.StateUpdated += x, x => _data.StateUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillRestoreState => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBWillRestoreEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBWillRestoreEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillRestoreState += x, x => _data.WillRestoreState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WriteRequestsReceived => global::System.Reactive.Linq.Observable.FromEvent, global::CoreBluetooth.CBATTRequestsEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreBluetooth.CBATTRequestsEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WriteRequestsReceived += x, x => _data.WriteRequestsReceived -= x); + } +} + +namespace CoreFoundation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCFSocketEvents Events(this global::CoreFoundation.CFSocket item) => new RxCFSocketEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCFStreamEvents Events(this global::CoreFoundation.CFStream item) => new RxCFStreamEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCFSocketEvents + { + private readonly global::CoreFoundation.CFSocket _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCFSocketEvents(global::CoreFoundation.CFSocket data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AcceptEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFSocket.CFSocketAcceptEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFSocket.CFSocketAcceptEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AcceptEvent += x, x => _data.AcceptEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ConnectEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFSocket.CFSocketConnectEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFSocket.CFSocketConnectEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ConnectEvent += x, x => _data.ConnectEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DataEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFSocket.CFSocketDataEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFSocket.CFSocketDataEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DataEvent += x, x => _data.DataEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReadEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFSocket.CFSocketReadEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFSocket.CFSocketReadEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReadEvent += x, x => _data.ReadEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WriteEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFSocket.CFSocketWriteEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFSocket.CFSocketWriteEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WriteEvent += x, x => _data.WriteEvent -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCFStreamEvents + { + private readonly global::CoreFoundation.CFStream _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCFStreamEvents(global::CoreFoundation.CFStream data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanAcceptBytesEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFStream.StreamEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFStream.StreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanAcceptBytesEvent += x, x => _data.CanAcceptBytesEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ClosedEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFStream.StreamEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFStream.StreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ClosedEvent += x, x => _data.ClosedEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFStream.StreamEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFStream.StreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorEvent += x, x => _data.ErrorEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable HasBytesAvailableEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFStream.StreamEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFStream.StreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.HasBytesAvailableEvent += x, x => _data.HasBytesAvailableEvent -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OpenCompletedEvent => global::System.Reactive.Linq.Observable.FromEvent, global::CoreFoundation.CFStream.StreamEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreFoundation.CFStream.StreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OpenCompletedEvent += x, x => _data.OpenCompletedEvent -= x); + } +} + +namespace CoreLocation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCLLocationManagerEvents Events(this global::CoreLocation.CLLocationManager item) => new RxCLLocationManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCLLocationManagerEvents + { + private readonly global::CoreLocation.CLLocationManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCLLocationManagerEvents(global::CoreLocation.CLLocationManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable AuthorizationChanged => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLAuthorizationChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLAuthorizationChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.AuthorizationChanged += x, x => _data.AuthorizationChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidChangeAuthorization => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidChangeAuthorization += x, x => _data.DidChangeAuthorization -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Failed => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Failed += x, x => _data.Failed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable LocationsUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLLocationsUpdatedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLLocationsUpdatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.LocationsUpdated += x, x => _data.LocationsUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdatedHeading => global::System.Reactive.Linq.Observable.FromEvent, global::CoreLocation.CLHeadingUpdatedEventArgs>(eventHandler => + { + void Handler(object sender, global::CoreLocation.CLHeadingUpdatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdatedHeading += x, x => _data.UpdatedHeading -= x); + } +} + +namespace Foundation +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSCacheEvents Events(this global::Foundation.NSCache item) => new RxNSCacheEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSKeyedArchiverEvents Events(this global::Foundation.NSKeyedArchiver item) => new RxNSKeyedArchiverEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSKeyedUnarchiverEvents Events(this global::Foundation.NSKeyedUnarchiver item) => new RxNSKeyedUnarchiverEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNSStreamEvents Events(this global::Foundation.NSStream item) => new RxNSStreamEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSCacheEvents + { + private readonly global::Foundation.NSCache _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSCacheEvents(global::Foundation.NSCache data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable WillEvictObject => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSObjectEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSObjectEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.WillEvictObject += x, x => _data.WillEvictObject -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSKeyedArchiverEvents + { + private readonly global::Foundation.NSKeyedArchiver _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSKeyedArchiverEvents(global::Foundation.NSKeyedArchiver data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable EncodedObject => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSObjectEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSObjectEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.EncodedObject += x, x => _data.EncodedObject -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finished += x, x => _data.Finished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finishing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finishing += x, x => _data.Finishing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReplacingObject => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSArchiveReplaceEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSArchiveReplaceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReplacingObject += x, x => _data.ReplacingObject -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSKeyedUnarchiverEvents + { + private readonly global::Foundation.NSKeyedUnarchiver _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSKeyedUnarchiverEvents(global::Foundation.NSKeyedUnarchiver data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finished += x, x => _data.Finished -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Finishing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Finishing += x, x => _data.Finishing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReplacingObject => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSArchiveReplaceEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSArchiveReplaceEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReplacingObject += x, x => _data.ReplacingObject -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNSStreamEvents + { + private readonly global::Foundation.NSStream _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNSStreamEvents(global::Foundation.NSStream data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OnEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Foundation.NSStreamEventArgs>(eventHandler => + { + void Handler(object sender, global::Foundation.NSStreamEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OnEvent += x, x => _data.OnEvent -= x); + } +} + +namespace HomeKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHMAccessoryEvents Events(this global::HomeKit.HMAccessory item) => new RxHMAccessoryEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHMHomeEvents Events(this global::HomeKit.HMHome item) => new RxHMHomeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxHMHomeManagerEvents Events(this global::HomeKit.HMHomeManager item) => new RxHMHomeManagerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHMAccessoryEvents + { + private readonly global::HomeKit.HMAccessory _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHMAccessoryEvents(global::HomeKit.HMAccessory data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddProfile => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMAccessoryProfileEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMAccessoryProfileEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddProfile += x, x => _data.DidAddProfile -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveProfile => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMAccessoryProfileEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMAccessoryProfileEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveProfile += x, x => _data.DidRemoveProfile -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateAssociatedServiceType => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMAccessoryUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMAccessoryUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateAssociatedServiceType += x, x => _data.DidUpdateAssociatedServiceType -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateFirmwareVersion => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMAccessoryFirmwareVersionEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMAccessoryFirmwareVersionEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateFirmwareVersion += x, x => _data.DidUpdateFirmwareVersion -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateName => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateName += x, x => _data.DidUpdateName -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateNameForService => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMAccessoryUpdateEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMAccessoryUpdateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateNameForService += x, x => _data.DidUpdateNameForService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateReachability => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateReachability += x, x => _data.DidUpdateReachability -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateServices => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateServices += x, x => _data.DidUpdateServices -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateValueForCharacteristic => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMAccessoryServiceUpdateCharacteristicEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMAccessoryServiceUpdateCharacteristicEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateValueForCharacteristic += x, x => _data.DidUpdateValueForCharacteristic -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHMHomeEvents + { + private readonly global::HomeKit.HMHome _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHMHomeEvents(global::HomeKit.HMHome data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddAccessory => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeAccessoryEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeAccessoryEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddAccessory += x, x => _data.DidAddAccessory -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddActionSet => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeActionSetEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeActionSetEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddActionSet += x, x => _data.DidAddActionSet -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddRoom => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeRoomEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeRoomEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddRoom += x, x => _data.DidAddRoom -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddRoomToZone => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeRoomZoneEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeRoomZoneEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddRoomToZone += x, x => _data.DidAddRoomToZone -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddService => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeServiceServiceGroupEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeServiceServiceGroupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddService += x, x => _data.DidAddService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddServiceGroup => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeServiceGroupEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeServiceGroupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddServiceGroup += x, x => _data.DidAddServiceGroup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddTrigger => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeTriggerEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeTriggerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddTrigger += x, x => _data.DidAddTrigger -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddUser => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeUserEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeUserEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddUser += x, x => _data.DidAddUser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddZone => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeZoneEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeZoneEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddZone += x, x => _data.DidAddZone -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEncounterError => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeErrorAccessoryEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeErrorAccessoryEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEncounterError += x, x => _data.DidEncounterError -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveAccessory => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeAccessoryEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeAccessoryEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveAccessory += x, x => _data.DidRemoveAccessory -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveActionSet => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeActionSetEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeActionSetEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveActionSet += x, x => _data.DidRemoveActionSet -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveRoom => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeRoomEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeRoomEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveRoom += x, x => _data.DidRemoveRoom -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveRoomFromZone => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeRoomZoneEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeRoomZoneEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveRoomFromZone += x, x => _data.DidRemoveRoomFromZone -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveService => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeServiceServiceGroupEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeServiceServiceGroupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveService += x, x => _data.DidRemoveService -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveServiceGroup => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeServiceGroupEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeServiceGroupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveServiceGroup += x, x => _data.DidRemoveServiceGroup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveTrigger => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeTriggerEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeTriggerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveTrigger += x, x => _data.DidRemoveTrigger -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveUser => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeUserEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeUserEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveUser += x, x => _data.DidRemoveUser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveZone => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeZoneEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeZoneEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveZone += x, x => _data.DidRemoveZone -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUnblockAccessory => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeAccessoryEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeAccessoryEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUnblockAccessory += x, x => _data.DidUnblockAccessory -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateAccessControlForCurrentUser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateAccessControlForCurrentUser += x, x => _data.DidUpdateAccessControlForCurrentUser -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateActionsForActionSet => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeActionSetEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeActionSetEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateActionsForActionSet += x, x => _data.DidUpdateActionsForActionSet -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateHomeHubState => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeHubStateEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeHubStateEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateHomeHubState += x, x => _data.DidUpdateHomeHubState -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateNameForActionSet => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeActionSetEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeActionSetEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateNameForActionSet += x, x => _data.DidUpdateNameForActionSet -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateNameForHome => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateNameForHome += x, x => _data.DidUpdateNameForHome -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateNameForRoom => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeRoomEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeRoomEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateNameForRoom += x, x => _data.DidUpdateNameForRoom -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateNameForServiceGroup => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeServiceGroupEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeServiceGroupEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateNameForServiceGroup += x, x => _data.DidUpdateNameForServiceGroup -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateNameForTrigger => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeTriggerEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeTriggerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateNameForTrigger += x, x => _data.DidUpdateNameForTrigger -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateNameForZone => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeZoneEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeZoneEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateNameForZone += x, x => _data.DidUpdateNameForZone -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateRoom => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeRoomAccessoryEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeRoomAccessoryEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateRoom += x, x => _data.DidUpdateRoom -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateSupportedFeatures => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateSupportedFeatures += x, x => _data.DidUpdateSupportedFeatures -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateTrigger => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeTriggerEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeTriggerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateTrigger += x, x => _data.DidUpdateTrigger -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxHMHomeManagerEvents + { + private readonly global::HomeKit.HMHomeManager _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxHMHomeManagerEvents(global::HomeKit.HMHomeManager data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidAddHome => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeManagerEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeManagerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidAddHome += x, x => _data.DidAddHome -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidRemoveHome => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeManagerEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeManagerEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidRemoveHome += x, x => _data.DidRemoveHome -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateAuthorizationStatus => global::System.Reactive.Linq.Observable.FromEvent, global::HomeKit.HMHomeManagerAuthorizationStatusEventArgs>(eventHandler => + { + void Handler(object sender, global::HomeKit.HMHomeManagerAuthorizationStatusEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateAuthorizationStatus += x, x => _data.DidUpdateAuthorizationStatus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateHomes => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateHomes += x, x => _data.DidUpdateHomes -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdatePrimaryHome => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdatePrimaryHome += x, x => _data.DidUpdatePrimaryHome -= x); + } +} + +namespace SceneKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSCNPhysicsWorldEvents Events(this global::SceneKit.SCNPhysicsWorld item) => new RxSCNPhysicsWorldEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSCNPhysicsWorldEvents + { + private readonly global::SceneKit.SCNPhysicsWorld _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSCNPhysicsWorldEvents(global::SceneKit.SCNPhysicsWorld data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidBeginContact => global::System.Reactive.Linq.Observable.FromEvent, global::SceneKit.SCNPhysicsContactEventArgs>(eventHandler => + { + void Handler(object sender, global::SceneKit.SCNPhysicsContactEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidBeginContact += x, x => _data.DidBeginContact -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEndContact => global::System.Reactive.Linq.Observable.FromEvent, global::SceneKit.SCNPhysicsContactEventArgs>(eventHandler => + { + void Handler(object sender, global::SceneKit.SCNPhysicsContactEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEndContact += x, x => _data.DidEndContact -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidUpdateContact => global::System.Reactive.Linq.Observable.FromEvent, global::SceneKit.SCNPhysicsContactEventArgs>(eventHandler => + { + void Handler(object sender, global::SceneKit.SCNPhysicsContactEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidUpdateContact += x, x => _data.DidUpdateContact -= x); + } +} + +namespace SpriteKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSKPhysicsWorldEvents Events(this global::SpriteKit.SKPhysicsWorld item) => new RxSKPhysicsWorldEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSKPhysicsWorldEvents + { + private readonly global::SpriteKit.SKPhysicsWorld _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSKPhysicsWorldEvents(global::SpriteKit.SKPhysicsWorld data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidBeginContact => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidBeginContact += x, x => _data.DidBeginContact -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DidEndContact => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DidEndContact += x, x => _data.DidEndContact -= x); + } +} + +namespace StoreKit +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSKProductsRequestEvents Events(this global::StoreKit.SKProductsRequest item) => new RxSKProductsRequestEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSKRequestEvents Events(this global::StoreKit.SKRequest item) => new RxSKRequestEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSKProductsRequestEvents : global::StoreKit.RxSKRequestEvents + { + private readonly global::StoreKit.SKProductsRequest _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSKProductsRequestEvents(global::StoreKit.SKProductsRequest data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ReceivedResponse => global::System.Reactive.Linq.Observable.FromEvent, global::StoreKit.SKProductsRequestResponseEventArgs>(eventHandler => + { + void Handler(object sender, global::StoreKit.SKProductsRequestResponseEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ReceivedResponse += x, x => _data.ReceivedResponse -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSKRequestEvents + { + private readonly global::StoreKit.SKRequest _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSKRequestEvents(global::StoreKit.SKRequest data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestFailed => global::System.Reactive.Linq.Observable.FromEvent, global::StoreKit.SKRequestErrorEventArgs>(eventHandler => + { + void Handler(object sender, global::StoreKit.SKRequestErrorEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestFailed += x, x => _data.RequestFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestFinished += x, x => _data.RequestFinished -= x); + } +} + +namespace ObjCRuntime +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RuntimeMarshalManagedException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::ObjCRuntime.MarshalManagedExceptionEventArgs args) => eventHandler(args); + return Handler; + }, x => global::ObjCRuntime.Runtime.MarshalManagedException += x, x => global::ObjCRuntime.Runtime.MarshalManagedException -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable RuntimeMarshalObjectiveCException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::ObjCRuntime.MarshalObjectiveCExceptionEventArgs args) => eventHandler(args); + return Handler; + }, x => global::ObjCRuntime.Runtime.MarshalObjectiveCException += x, x => global::ObjCRuntime.Runtime.MarshalObjectiveCException -= x); + } +} + +namespace AuthenticationServices +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class ASAuthorizationControllerDelegateRx : global::AuthenticationServices.ASAuthorizationControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AuthenticationServices.ASAuthorizationController controller, global::AuthenticationServices.ASAuthorization authorization)> _didComplete = new Pharmacist.Common.SingleAwaitSubject<(global::AuthenticationServices.ASAuthorizationController controller, global::AuthenticationServices.ASAuthorization authorization)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AuthenticationServices.ASAuthorizationController controller, global::AuthenticationServices.ASAuthorization authorization)> DidCompleteObs => _didComplete; + /// + public override void DidComplete(global::AuthenticationServices.ASAuthorizationController controller, global::AuthenticationServices.ASAuthorization authorization) => _didComplete.OnNext((controller, authorization)); + } +} + +namespace AVFoundation +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVAudioPlayerDelegateRx : global::AVFoundation.AVAudioPlayerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _beginInterruption = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, global::Foundation.NSError error)> _decoderError = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, global::AVFoundation.AVAudioSessionInterruptionFlags flags)> _endInterruption = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, global::AVFoundation.AVAudioSessionInterruptionFlags flags)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, bool flag)> _finishedPlaying = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioPlayer player, bool flag)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable BeginInterruptionObs => _beginInterruption; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioPlayer player, global::Foundation.NSError error)> DecoderErrorObs => _decoderError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioPlayer player, global::AVFoundation.AVAudioSessionInterruptionFlags flags)> EndInterruptionObs => _endInterruption; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioPlayer player, bool flag)> FinishedPlayingObs => _finishedPlaying; + /// + public override void BeginInterruption(global::AVFoundation.AVAudioPlayer player) => _beginInterruption.OnNext(player); + /// + public override void DecoderError(global::AVFoundation.AVAudioPlayer player, global::Foundation.NSError error) => _decoderError.OnNext((player, error)); + /// + public override void EndInterruption(global::AVFoundation.AVAudioPlayer player, global::AVFoundation.AVAudioSessionInterruptionFlags flags) => _endInterruption.OnNext((player, flags)); + /// + public override void FinishedPlaying(global::AVFoundation.AVAudioPlayer player, bool flag) => _finishedPlaying.OnNext((player, flag)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVAudioRecorderDelegateRx : global::AVFoundation.AVAudioRecorderDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _beginInterruption = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, global::Foundation.NSError error)> _encoderError = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, global::AVFoundation.AVAudioSessionInterruptionFlags flags)> _endInterruption = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, global::AVFoundation.AVAudioSessionInterruptionFlags flags)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, bool flag)> _finishedRecording = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVAudioRecorder recorder, bool flag)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable BeginInterruptionObs => _beginInterruption; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioRecorder recorder, global::Foundation.NSError error)> EncoderErrorObs => _encoderError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioRecorder recorder, global::AVFoundation.AVAudioSessionInterruptionFlags flags)> EndInterruptionObs => _endInterruption; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVAudioRecorder recorder, bool flag)> FinishedRecordingObs => _finishedRecording; + /// + public override void BeginInterruption(global::AVFoundation.AVAudioRecorder recorder) => _beginInterruption.OnNext(recorder); + /// + public override void EncoderError(global::AVFoundation.AVAudioRecorder recorder, global::Foundation.NSError error) => _encoderError.OnNext((recorder, error)); + /// + public override void EndInterruption(global::AVFoundation.AVAudioRecorder recorder, global::AVFoundation.AVAudioSessionInterruptionFlags flags) => _endInterruption.OnNext((recorder, flags)); + /// + public override void FinishedRecording(global::AVFoundation.AVAudioRecorder recorder, bool flag) => _finishedRecording.OnNext((recorder, flag)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class AVContentKeySessionDelegateRx : global::AVFoundation.AVContentKeySessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest, global::Foundation.NSError err)> _didFail = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest, global::Foundation.NSError err)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didGenerateExpiredSessionReport = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> _didProvideContentKeyRequest = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVPersistableContentKeyRequest keyRequest)> _didProvidePersistableContentKeyRequest = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVPersistableContentKeyRequest keyRequest)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> _didProvideRenewingContentKeyRequest = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> _didSucceed = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::Foundation.NSData persistableContentKey, global::Foundation.NSObject keyIdentifier)> _didUpdate = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVContentKeySession session, global::Foundation.NSData persistableContentKey, global::Foundation.NSObject keyIdentifier)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeObs => _didChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest, global::Foundation.NSError err)> DidFailObs => _didFail; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidGenerateExpiredSessionReportObs => _didGenerateExpiredSessionReport; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> DidProvideContentKeyRequestObs => _didProvideContentKeyRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVPersistableContentKeyRequest keyRequest)> DidProvidePersistableContentKeyRequestObs => _didProvidePersistableContentKeyRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> DidProvideRenewingContentKeyRequestObs => _didProvideRenewingContentKeyRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest)> DidSucceedObs => _didSucceed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVContentKeySession session, global::Foundation.NSData persistableContentKey, global::Foundation.NSObject keyIdentifier)> DidUpdateObs => _didUpdate; + /// + public override void DidChange(global::AVFoundation.AVContentKeySession session) => _didChange.OnNext(session); + /// + public override void DidFail(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest, global::Foundation.NSError err) => _didFail.OnNext((session, keyRequest, err)); + /// + public override void DidGenerateExpiredSessionReport(global::AVFoundation.AVContentKeySession session) => _didGenerateExpiredSessionReport.OnNext(session); + /// + public override void DidProvideContentKeyRequest(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest) => _didProvideContentKeyRequest.OnNext((session, keyRequest)); + /// + public override void DidProvidePersistableContentKeyRequest(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVPersistableContentKeyRequest keyRequest) => _didProvidePersistableContentKeyRequest.OnNext((session, keyRequest)); + /// + public override void DidProvideRenewingContentKeyRequest(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest) => _didProvideRenewingContentKeyRequest.OnNext((session, keyRequest)); + /// + public override void DidSucceed(global::AVFoundation.AVContentKeySession session, global::AVFoundation.AVContentKeyRequest keyRequest) => _didSucceed.OnNext((session, keyRequest)); + /// + public override void DidUpdate(global::AVFoundation.AVContentKeySession session, global::Foundation.NSData persistableContentKey, global::Foundation.NSObject keyIdentifier) => _didUpdate.OnNext((session, persistableContentKey, keyIdentifier)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class AVPlayerItemMetadataCollectorPushDelegateRx : global::AVFoundation.AVPlayerItemMetadataCollectorPushDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVPlayerItemMetadataCollector metadataCollector, global::AVFoundation.AVDateRangeMetadataGroup[] metadataGroups, global::Foundation.NSIndexSet indexesOfNewGroups, global::Foundation.NSIndexSet indexesOfModifiedGroups)> _didCollectDateRange = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVPlayerItemMetadataCollector metadataCollector, global::AVFoundation.AVDateRangeMetadataGroup[] metadataGroups, global::Foundation.NSIndexSet indexesOfNewGroups, global::Foundation.NSIndexSet indexesOfModifiedGroups)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVPlayerItemMetadataCollector metadataCollector, global::AVFoundation.AVDateRangeMetadataGroup[] metadataGroups, global::Foundation.NSIndexSet indexesOfNewGroups, global::Foundation.NSIndexSet indexesOfModifiedGroups)> DidCollectDateRangeObs => _didCollectDateRange; + /// + public override void DidCollectDateRange(global::AVFoundation.AVPlayerItemMetadataCollector metadataCollector, global::AVFoundation.AVDateRangeMetadataGroup[] metadataGroups, global::Foundation.NSIndexSet indexesOfNewGroups, global::Foundation.NSIndexSet indexesOfModifiedGroups) => _didCollectDateRange.OnNext((metadataCollector, metadataGroups, indexesOfNewGroups, indexesOfModifiedGroups)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVPlayerItemMetadataOutputPushDelegateRx : global::AVFoundation.AVPlayerItemMetadataOutputPushDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVPlayerItemMetadataOutput output, global::AVFoundation.AVTimedMetadataGroup[] groups, global::AVFoundation.AVPlayerItemTrack track)> _didOutputTimedMetadataGroups = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVPlayerItemMetadataOutput output, global::AVFoundation.AVTimedMetadataGroup[] groups, global::AVFoundation.AVPlayerItemTrack track)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _outputSequenceWasFlushed = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVPlayerItemMetadataOutput output, global::AVFoundation.AVTimedMetadataGroup[] groups, global::AVFoundation.AVPlayerItemTrack track)> DidOutputTimedMetadataGroupsObs => _didOutputTimedMetadataGroups; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OutputSequenceWasFlushedObs => _outputSequenceWasFlushed; + /// + public override void DidOutputTimedMetadataGroups(global::AVFoundation.AVPlayerItemMetadataOutput output, global::AVFoundation.AVTimedMetadataGroup[] groups, global::AVFoundation.AVPlayerItemTrack track) => _didOutputTimedMetadataGroups.OnNext((output, groups, track)); + /// + public override void OutputSequenceWasFlushed(global::AVFoundation.AVPlayerItemOutput output) => _outputSequenceWasFlushed.OnNext(output); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVPlayerItemOutputPullDelegateRx : global::AVFoundation.AVPlayerItemOutputPullDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _outputMediaDataWillChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _outputSequenceWasFlushed = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OutputMediaDataWillChangeObs => _outputMediaDataWillChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OutputSequenceWasFlushedObs => _outputSequenceWasFlushed; + /// + public override void OutputMediaDataWillChange(global::AVFoundation.AVPlayerItemOutput sender) => _outputMediaDataWillChange.OnNext(sender); + /// + public override void OutputSequenceWasFlushed(global::AVFoundation.AVPlayerItemOutput output) => _outputSequenceWasFlushed.OnNext(output); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVPlayerItemOutputPushDelegateRx : global::AVFoundation.AVPlayerItemOutputPushDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _outputSequenceWasFlushed = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable OutputSequenceWasFlushedObs => _outputSequenceWasFlushed; + /// + public override void OutputSequenceWasFlushed(global::AVFoundation.AVPlayerItemOutput output) => _outputSequenceWasFlushed.OnNext(output); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class AVSpeechSynthesizerDelegateRx : global::AVFoundation.AVSpeechSynthesizerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> _didCancelSpeechUtterance = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> _didContinueSpeechUtterance = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> _didFinishSpeechUtterance = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> _didPauseSpeechUtterance = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> _didStartSpeechUtterance = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::Foundation.NSRange characterRange, global::AVFoundation.AVSpeechUtterance utterance)> _willSpeakRangeOfSpeechString = new Pharmacist.Common.SingleAwaitSubject<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::Foundation.NSRange characterRange, global::AVFoundation.AVSpeechUtterance utterance)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> DidCancelSpeechUtteranceObs => _didCancelSpeechUtterance; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> DidContinueSpeechUtteranceObs => _didContinueSpeechUtterance; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> DidFinishSpeechUtteranceObs => _didFinishSpeechUtterance; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> DidPauseSpeechUtteranceObs => _didPauseSpeechUtterance; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance)> DidStartSpeechUtteranceObs => _didStartSpeechUtterance; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::Foundation.NSRange characterRange, global::AVFoundation.AVSpeechUtterance utterance)> WillSpeakRangeOfSpeechStringObs => _willSpeakRangeOfSpeechString; + /// + public override void DidCancelSpeechUtterance(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance) => _didCancelSpeechUtterance.OnNext((synthesizer, utterance)); + /// + public override void DidContinueSpeechUtterance(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance) => _didContinueSpeechUtterance.OnNext((synthesizer, utterance)); + /// + public override void DidFinishSpeechUtterance(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance) => _didFinishSpeechUtterance.OnNext((synthesizer, utterance)); + /// + public override void DidPauseSpeechUtterance(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance) => _didPauseSpeechUtterance.OnNext((synthesizer, utterance)); + /// + public override void DidStartSpeechUtterance(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::AVFoundation.AVSpeechUtterance utterance) => _didStartSpeechUtterance.OnNext((synthesizer, utterance)); + /// + public override void WillSpeakRangeOfSpeechString(global::AVFoundation.AVSpeechSynthesizer synthesizer, global::Foundation.NSRange characterRange, global::AVFoundation.AVSpeechUtterance utterance) => _willSpeakRangeOfSpeechString.OnNext((synthesizer, characterRange, utterance)); + } +} + +namespace CoreBluetooth +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CBCentralManagerDelegateRx : global::CoreBluetooth.CBCentralManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral)> _connectedPeripheral = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBConnectionEvent connectionEvent, global::CoreBluetooth.CBPeripheral peripheral)> _connectionEventDidOccur = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBConnectionEvent connectionEvent, global::CoreBluetooth.CBPeripheral peripheral)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral)> _didUpdateAncsAuthorization = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> _disconnectedPeripheral = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSDictionary advertisementData, global::Foundation.NSNumber RSSI)> _discoveredPeripheral = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSDictionary advertisementData, global::Foundation.NSNumber RSSI)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> _failedToConnectPeripheral = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _updatedState = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::Foundation.NSDictionary dict)> _willRestoreState = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBCentralManager central, global::Foundation.NSDictionary dict)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral)> ConnectedPeripheralObs => _connectedPeripheral; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBConnectionEvent connectionEvent, global::CoreBluetooth.CBPeripheral peripheral)> ConnectionEventDidOccurObs => _connectionEventDidOccur; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral)> DidUpdateAncsAuthorizationObs => _didUpdateAncsAuthorization; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> DisconnectedPeripheralObs => _disconnectedPeripheral; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSDictionary advertisementData, global::Foundation.NSNumber RSSI)> DiscoveredPeripheralObs => _discoveredPeripheral; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> FailedToConnectPeripheralObs => _failedToConnectPeripheral; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UpdatedStateObs => _updatedState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBCentralManager central, global::Foundation.NSDictionary dict)> WillRestoreStateObs => _willRestoreState; + /// + public override void ConnectedPeripheral(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral) => _connectedPeripheral.OnNext((central, peripheral)); + /// + public override void ConnectionEventDidOccur(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBConnectionEvent connectionEvent, global::CoreBluetooth.CBPeripheral peripheral) => _connectionEventDidOccur.OnNext((central, connectionEvent, peripheral)); + /// + public override void DidUpdateAncsAuthorization(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral) => _didUpdateAncsAuthorization.OnNext((central, peripheral)); + /// + public override void DisconnectedPeripheral(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error) => _disconnectedPeripheral.OnNext((central, peripheral, error)); + /// + public override void DiscoveredPeripheral(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSDictionary advertisementData, global::Foundation.NSNumber RSSI) => _discoveredPeripheral.OnNext((central, peripheral, advertisementData, RSSI)); + /// + public override void FailedToConnectPeripheral(global::CoreBluetooth.CBCentralManager central, global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error) => _failedToConnectPeripheral.OnNext((central, peripheral, error)); + /// + public override void UpdatedState(global::CoreBluetooth.CBCentralManager central) => _updatedState.OnNext(central); + /// + public override void WillRestoreState(global::CoreBluetooth.CBCentralManager central, global::Foundation.NSDictionary dict) => _willRestoreState.OnNext((central, dict)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class CBPeripheralDelegateRx : global::CoreBluetooth.CBPeripheralDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)> _didOpenL2CapChannel = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> _discoveredCharacteristic = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> _discoveredDescriptor = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> _discoveredIncludedService = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> _discoveredService = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _isReadyToSendWriteWithoutResponse = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService[] services)> _modifiedServices = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService[] services)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSNumber rssi, global::Foundation.NSError error)> _rssiRead = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSNumber rssi, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> _rssiUpdated = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> _updatedCharacterteristicValue = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _updatedName = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> _updatedNotificationState = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)> _updatedValue = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> _wroteCharacteristicValue = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)> _wroteDescriptorValue = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)> DidOpenL2CapChannelObs => _didOpenL2CapChannel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> DiscoveredCharacteristicObs => _discoveredCharacteristic; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> DiscoveredDescriptorObs => _discoveredDescriptor; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> DiscoveredIncludedServiceObs => _discoveredIncludedService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> DiscoveredServiceObs => _discoveredService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable IsReadyToSendWriteWithoutResponseObs => _isReadyToSendWriteWithoutResponse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService[] services)> ModifiedServicesObs => _modifiedServices; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSNumber rssi, global::Foundation.NSError error)> RssiReadObs => _rssiRead; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error)> RssiUpdatedObs => _rssiUpdated; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> UpdatedCharacterteristicValueObs => _updatedCharacterteristicValue; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UpdatedNameObs => _updatedName; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> UpdatedNotificationStateObs => _updatedNotificationState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)> UpdatedValueObs => _updatedValue; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error)> WroteCharacteristicValueObs => _wroteCharacteristicValue; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error)> WroteDescriptorValueObs => _wroteDescriptorValue; + /// + public override void DidOpenL2CapChannel(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error) => _didOpenL2CapChannel.OnNext((peripheral, channel, error)); + /// + public override void DiscoveredCharacteristic(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error) => _discoveredCharacteristic.OnNext((peripheral, service, error)); + /// + public override void DiscoveredDescriptor(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error) => _discoveredDescriptor.OnNext((peripheral, characteristic, error)); + /// + public override void DiscoveredIncludedService(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error) => _discoveredIncludedService.OnNext((peripheral, service, error)); + /// + public override void DiscoveredService(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error) => _discoveredService.OnNext((peripheral, error)); + /// + public override void IsReadyToSendWriteWithoutResponse(global::CoreBluetooth.CBPeripheral peripheral) => _isReadyToSendWriteWithoutResponse.OnNext(peripheral); + /// + public override void ModifiedServices(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBService[] services) => _modifiedServices.OnNext((peripheral, services)); + /// + public override void RssiRead(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSNumber rssi, global::Foundation.NSError error) => _rssiRead.OnNext((peripheral, rssi, error)); + /// + public override void RssiUpdated(global::CoreBluetooth.CBPeripheral peripheral, global::Foundation.NSError error) => _rssiUpdated.OnNext((peripheral, error)); + /// + public override void UpdatedCharacterteristicValue(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error) => _updatedCharacterteristicValue.OnNext((peripheral, characteristic, error)); + /// + public override void UpdatedName(global::CoreBluetooth.CBPeripheral peripheral) => _updatedName.OnNext(peripheral); + /// + public override void UpdatedNotificationState(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error) => _updatedNotificationState.OnNext((peripheral, characteristic, error)); + /// + public override void UpdatedValue(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error) => _updatedValue.OnNext((peripheral, descriptor, error)); + /// + public override void WroteCharacteristicValue(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBCharacteristic characteristic, global::Foundation.NSError error) => _wroteCharacteristicValue.OnNext((peripheral, characteristic, error)); + /// + public override void WroteDescriptorValue(global::CoreBluetooth.CBPeripheral peripheral, global::CoreBluetooth.CBDescriptor descriptor, global::Foundation.NSError error) => _wroteDescriptorValue.OnNext((peripheral, descriptor, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class CBPeripheralManagerDelegateRx : global::CoreBluetooth.CBPeripheralManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSError error)> _advertisingStarted = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)> _characteristicSubscribed = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)> _characteristicUnsubscribed = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)> _didOpenL2CapChannel = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)> _didPublishL2CapChannel = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)> _didUnpublishL2CapChannel = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest request)> _readRequestReceived = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest request)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _readyToUpdateSubscribers = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> _serviceAdded = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _stateUpdated = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSDictionary dict)> _willRestoreState = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSDictionary dict)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest[] requests)> _writeRequestsReceived = new Pharmacist.Common.SingleAwaitSubject<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest[] requests)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSError error)> AdvertisingStartedObs => _advertisingStarted; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)> CharacteristicSubscribedObs => _characteristicSubscribed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic)> CharacteristicUnsubscribedObs => _characteristicUnsubscribed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error)> DidOpenL2CapChannelObs => _didOpenL2CapChannel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)> DidPublishL2CapChannelObs => _didPublishL2CapChannel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error)> DidUnpublishL2CapChannelObs => _didUnpublishL2CapChannel; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest request)> ReadRequestReceivedObs => _readRequestReceived; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ReadyToUpdateSubscribersObs => _readyToUpdateSubscribers; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error)> ServiceAddedObs => _serviceAdded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable StateUpdatedObs => _stateUpdated; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSDictionary dict)> WillRestoreStateObs => _willRestoreState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest[] requests)> WriteRequestsReceivedObs => _writeRequestsReceived; + /// + public override void AdvertisingStarted(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSError error) => _advertisingStarted.OnNext((peripheral, error)); + /// + public override void CharacteristicSubscribed(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic) => _characteristicSubscribed.OnNext((peripheral, central, characteristic)); + /// + public override void CharacteristicUnsubscribed(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBCentral central, global::CoreBluetooth.CBCharacteristic characteristic) => _characteristicUnsubscribed.OnNext((peripheral, central, characteristic)); + /// + public override void DidOpenL2CapChannel(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBL2CapChannel channel, global::Foundation.NSError error) => _didOpenL2CapChannel.OnNext((peripheral, channel, error)); + /// + public override void DidPublishL2CapChannel(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error) => _didPublishL2CapChannel.OnNext((peripheral, psm, error)); + /// + public override void DidUnpublishL2CapChannel(global::CoreBluetooth.CBPeripheralManager peripheral, ushort psm, global::Foundation.NSError error) => _didUnpublishL2CapChannel.OnNext((peripheral, psm, error)); + /// + public override void ReadRequestReceived(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest request) => _readRequestReceived.OnNext((peripheral, request)); + /// + public override void ReadyToUpdateSubscribers(global::CoreBluetooth.CBPeripheralManager peripheral) => _readyToUpdateSubscribers.OnNext(peripheral); + /// + public override void ServiceAdded(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBService service, global::Foundation.NSError error) => _serviceAdded.OnNext((peripheral, service, error)); + /// + public override void StateUpdated(global::CoreBluetooth.CBPeripheralManager peripheral) => _stateUpdated.OnNext(peripheral); + /// + public override void WillRestoreState(global::CoreBluetooth.CBPeripheralManager peripheral, global::Foundation.NSDictionary dict) => _willRestoreState.OnNext((peripheral, dict)); + /// + public override void WriteRequestsReceived(global::CoreBluetooth.CBPeripheralManager peripheral, global::CoreBluetooth.CBATTRequest[] requests) => _writeRequestsReceived.OnNext((peripheral, requests)); + } +} + +namespace CoreData +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSFetchedResultsControllerDelegateRx : global::CoreData.NSFetchedResultsControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeContent = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreData.NSFetchedResultsController controller, global::Foundation.NSObject anObject, global::Foundation.NSIndexPath indexPath, global::CoreData.NSFetchedResultsChangeType type, global::Foundation.NSIndexPath newIndexPath)> _didChangeObject = new Pharmacist.Common.SingleAwaitSubject<(global::CoreData.NSFetchedResultsController controller, global::Foundation.NSObject anObject, global::Foundation.NSIndexPath indexPath, global::CoreData.NSFetchedResultsChangeType type, global::Foundation.NSIndexPath newIndexPath)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreData.NSFetchedResultsController controller, global::CoreData.INSFetchedResultsSectionInfo sectionInfo, global::System.nuint sectionIndex, global::CoreData.NSFetchedResultsChangeType type)> _didChangeSection = new Pharmacist.Common.SingleAwaitSubject<(global::CoreData.NSFetchedResultsController controller, global::CoreData.INSFetchedResultsSectionInfo sectionInfo, global::System.nuint sectionIndex, global::CoreData.NSFetchedResultsChangeType type)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willChangeContent = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeContentObs => _didChangeContent; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreData.NSFetchedResultsController controller, global::Foundation.NSObject anObject, global::Foundation.NSIndexPath indexPath, global::CoreData.NSFetchedResultsChangeType type, global::Foundation.NSIndexPath newIndexPath)> DidChangeObjectObs => _didChangeObject; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreData.NSFetchedResultsController controller, global::CoreData.INSFetchedResultsSectionInfo sectionInfo, global::System.nuint sectionIndex, global::CoreData.NSFetchedResultsChangeType type)> DidChangeSectionObs => _didChangeSection; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillChangeContentObs => _willChangeContent; + /// + public override void DidChangeContent(global::CoreData.NSFetchedResultsController controller) => _didChangeContent.OnNext(controller); + /// + public override void DidChangeObject(global::CoreData.NSFetchedResultsController controller, global::Foundation.NSObject anObject, global::Foundation.NSIndexPath indexPath, global::CoreData.NSFetchedResultsChangeType type, global::Foundation.NSIndexPath newIndexPath) => _didChangeObject.OnNext((controller, anObject, indexPath, type, newIndexPath)); + /// + public override void DidChangeSection(global::CoreData.NSFetchedResultsController controller, global::CoreData.INSFetchedResultsSectionInfo sectionInfo, global::System.nuint sectionIndex, global::CoreData.NSFetchedResultsChangeType type) => _didChangeSection.OnNext((controller, sectionInfo, sectionIndex, type)); + /// + public override void WillChangeContent(global::CoreData.NSFetchedResultsController controller) => _willChangeContent.OnNext(controller); + } +} + +namespace CoreLocation +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class CLLocationManagerDelegateRx : global::CoreLocation.CLLocationManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLAuthorizationStatus status)> _authorizationChanged = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLAuthorizationStatus status)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didChangeAuthorization = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error)> _failed = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation[] locations)> _locationsUpdated = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation[] locations)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLHeading newHeading)> _updatedHeading = new Pharmacist.Common.SingleAwaitSubject<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLHeading newHeading)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLAuthorizationStatus status)> AuthorizationChangedObs => _authorizationChanged; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidChangeAuthorizationObs => _didChangeAuthorization; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error)> FailedObs => _failed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation[] locations)> LocationsUpdatedObs => _locationsUpdated; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLHeading newHeading)> UpdatedHeadingObs => _updatedHeading; + /// + public override void AuthorizationChanged(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLAuthorizationStatus status) => _authorizationChanged.OnNext((manager, status)); + /// + public override void DidChangeAuthorization(global::CoreLocation.CLLocationManager manager) => _didChangeAuthorization.OnNext(manager); + /// + public override void Failed(global::CoreLocation.CLLocationManager manager, global::Foundation.NSError error) => _failed.OnNext((manager, error)); + /// + public override void LocationsUpdated(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLLocation[] locations) => _locationsUpdated.OnNext((manager, locations)); + /// + public override void UpdatedHeading(global::CoreLocation.CLLocationManager manager, global::CoreLocation.CLHeading newHeading) => _updatedHeading.OnNext((manager, newHeading)); + } +} + +namespace CoreMotion +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class CMHeadphoneMotionManagerDelegateRx : global::CoreMotion.CMHeadphoneMotionManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didConnect = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didDisconnect = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidConnectObs => _didConnect; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidDisconnectObs => _didDisconnect; + /// + public override void DidConnect(global::CoreMotion.CMHeadphoneMotionManager manager) => _didConnect.OnNext(manager); + /// + public override void DidDisconnect(global::CoreMotion.CMHeadphoneMotionManager manager) => _didDisconnect.OnNext(manager); + } +} + +namespace Foundation +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSCacheDelegateRx : global::Foundation.NSCacheDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSCache cache, global::Foundation.NSObject obj)> _willEvictObject = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSCache cache, global::Foundation.NSObject obj)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSCache cache, global::Foundation.NSObject obj)> WillEvictObjectObs => _willEvictObject; + /// + public override void WillEvictObject(global::Foundation.NSCache cache, global::Foundation.NSObject obj) => _willEvictObject.OnNext((cache, obj)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSKeyedArchiverDelegateRx : global::Foundation.NSKeyedArchiverDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject obj)> _encodedObject = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject obj)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _finished = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _finishing = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)> _replacingObject = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject obj)> EncodedObjectObs => _encodedObject; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedObs => _finished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishingObs => _finishing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)> ReplacingObjectObs => _replacingObject; + /// + public override void EncodedObject(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject obj) => _encodedObject.OnNext((archiver, obj)); + /// + public override void Finished(global::Foundation.NSKeyedArchiver archiver) => _finished.OnNext(archiver); + /// + public override void Finishing(global::Foundation.NSKeyedArchiver archiver) => _finishing.OnNext(archiver); + /// + public override void ReplacingObject(global::Foundation.NSKeyedArchiver archiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject) => _replacingObject.OnNext((archiver, oldObject, newObject)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSKeyedUnarchiverDelegateRx : global::Foundation.NSKeyedUnarchiverDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _finished = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _finishing = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedUnarchiver unarchiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)> _replacingObject = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSKeyedUnarchiver unarchiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedObs => _finished; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishingObs => _finishing; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSKeyedUnarchiver unarchiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject)> ReplacingObjectObs => _replacingObject; + /// + public override void Finished(global::Foundation.NSKeyedUnarchiver unarchiver) => _finished.OnNext(unarchiver); + /// + public override void Finishing(global::Foundation.NSKeyedUnarchiver unarchiver) => _finishing.OnNext(unarchiver); + /// + public override void ReplacingObject(global::Foundation.NSKeyedUnarchiver unarchiver, global::Foundation.NSObject oldObject, global::Foundation.NSObject newObject) => _replacingObject.OnNext((unarchiver, oldObject, newObject)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSMachPortDelegateRx : global::Foundation.NSMachPortDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _machMessageReceived = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable MachMessageReceivedObs => _machMessageReceived; + /// + public override void MachMessageReceived(global::System.IntPtr msgHeader) => _machMessageReceived.OnNext(msgHeader); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSPortDelegateRx : global::Foundation.NSPortDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _messageReceived = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable MessageReceivedObs => _messageReceived; + /// + public override void MessageReceived(global::Foundation.NSPortMessage message) => _messageReceived.OnNext(message); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSStreamDelegateRx : global::Foundation.NSStreamDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSStream theStream, global::Foundation.NSStreamEvent streamEvent)> _handleEvent = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSStream theStream, global::Foundation.NSStreamEvent streamEvent)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSStream theStream, global::Foundation.NSStreamEvent streamEvent)> HandleEventObs => _handleEvent; + /// + public override void HandleEvent(global::Foundation.NSStream theStream, global::Foundation.NSStreamEvent streamEvent) => _handleEvent.OnNext((theStream, streamEvent)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlConnectionDataDelegateRx : global::Foundation.NSUrlConnectionDataDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _finishedLoading = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSData data)> _receivedData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlResponse response)> _receivedResponse = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlResponse response)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::System.nint bytesWritten, global::System.nint totalBytesWritten, global::System.nint totalBytesExpectedToWrite)> _sentBodyData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::System.nint bytesWritten, global::System.nint totalBytesWritten, global::System.nint totalBytesExpectedToWrite)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable FinishedLoadingObs => _finishedLoading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSData data)> ReceivedDataObs => _receivedData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlResponse response)> ReceivedResponseObs => _receivedResponse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::System.nint bytesWritten, global::System.nint totalBytesWritten, global::System.nint totalBytesExpectedToWrite)> SentBodyDataObs => _sentBodyData; + /// + public override void FinishedLoading(global::Foundation.NSUrlConnection connection) => _finishedLoading.OnNext(connection); + /// + public override void ReceivedData(global::Foundation.NSUrlConnection connection, global::Foundation.NSData data) => _receivedData.OnNext((connection, data)); + /// + public override void ReceivedResponse(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlResponse response) => _receivedResponse.OnNext((connection, response)); + /// + public override void SentBodyData(global::Foundation.NSUrlConnection connection, global::System.nint bytesWritten, global::System.nint totalBytesWritten, global::System.nint totalBytesExpectedToWrite) => _sentBodyData.OnNext((connection, bytesWritten, totalBytesWritten, totalBytesExpectedToWrite)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlConnectionDelegateRx : global::Foundation.NSUrlConnectionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> _canceledAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSError error)> _failedWithError = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> _receivedAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> _willSendRequestForAuthenticationChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> CanceledAuthenticationChallengeObs => _canceledAuthenticationChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSError error)> FailedWithErrorObs => _failedWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> ReceivedAuthenticationChallengeObs => _receivedAuthenticationChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge)> WillSendRequestForAuthenticationChallengeObs => _willSendRequestForAuthenticationChallenge; + /// + public override void CanceledAuthenticationChallenge(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge) => _canceledAuthenticationChallenge.OnNext((connection, challenge)); + /// + public override void FailedWithError(global::Foundation.NSUrlConnection connection, global::Foundation.NSError error) => _failedWithError.OnNext((connection, error)); + /// + public override void ReceivedAuthenticationChallenge(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge) => _receivedAuthenticationChallenge.OnNext((connection, challenge)); + /// + public override void WillSendRequestForAuthenticationChallenge(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrlAuthenticationChallenge challenge) => _willSendRequestForAuthenticationChallenge.OnNext((connection, challenge)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NSUrlConnectionDownloadDelegateRx : global::Foundation.NSUrlConnectionDownloadDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrl destinationUrl)> _finishedDownloading = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrl destinationUrl)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, long totalBytesWritten, long expectedTotalBytes)> _resumedDownloading = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, long totalBytesWritten, long expectedTotalBytes)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, long bytesWritten, long totalBytesWritten, long expectedTotalBytes)> _wroteData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlConnection connection, long bytesWritten, long totalBytesWritten, long expectedTotalBytes)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrl destinationUrl)> FinishedDownloadingObs => _finishedDownloading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, long totalBytesWritten, long expectedTotalBytes)> ResumedDownloadingObs => _resumedDownloading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlConnection connection, long bytesWritten, long totalBytesWritten, long expectedTotalBytes)> WroteDataObs => _wroteData; + /// + public override void FinishedDownloading(global::Foundation.NSUrlConnection connection, global::Foundation.NSUrl destinationUrl) => _finishedDownloading.OnNext((connection, destinationUrl)); + /// + public override void ResumedDownloading(global::Foundation.NSUrlConnection connection, long totalBytesWritten, long expectedTotalBytes) => _resumedDownloading.OnNext((connection, totalBytesWritten, expectedTotalBytes)); + /// + public override void WroteData(global::Foundation.NSUrlConnection connection, long bytesWritten, long totalBytesWritten, long expectedTotalBytes) => _wroteData.OnNext((connection, bytesWritten, totalBytesWritten, expectedTotalBytes)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlSessionDataDelegateRx : global::Foundation.NSUrlSessionDataDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionDownloadTask downloadTask)> _didBecomeDownloadTask = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionDownloadTask downloadTask)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionStreamTask streamTask)> _didBecomeStreamTask = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionStreamTask streamTask)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSData data)> _didReceiveData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSData data)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlResponse response, global::System.Action completionHandler)> _didReceiveResponse = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlResponse response, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSCachedUrlResponse proposedResponse, global::System.Action completionHandler)> _willCacheResponse = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSCachedUrlResponse proposedResponse, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionDownloadTask downloadTask)> DidBecomeDownloadTaskObs => _didBecomeDownloadTask; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionStreamTask streamTask)> DidBecomeStreamTaskObs => _didBecomeStreamTask; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSData data)> DidReceiveDataObs => _didReceiveData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlResponse response, global::System.Action completionHandler)> DidReceiveResponseObs => _didReceiveResponse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSCachedUrlResponse proposedResponse, global::System.Action completionHandler)> WillCacheResponseObs => _willCacheResponse; + /// + public override void DidBecomeDownloadTask(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionDownloadTask downloadTask) => _didBecomeDownloadTask.OnNext((session, dataTask, downloadTask)); + /// + public override void DidBecomeStreamTask(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlSessionStreamTask streamTask) => _didBecomeStreamTask.OnNext((session, dataTask, streamTask)); + /// + public override void DidReceiveData(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSData data) => _didReceiveData.OnNext((session, dataTask, data)); + /// + public override void DidReceiveResponse(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSUrlResponse response, global::System.Action completionHandler) => _didReceiveResponse.OnNext((session, dataTask, response, completionHandler)); + /// + public override void WillCacheResponse(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDataTask dataTask, global::Foundation.NSCachedUrlResponse proposedResponse, global::System.Action completionHandler) => _willCacheResponse.OnNext((session, dataTask, proposedResponse, completionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlSessionDelegateRx : global::Foundation.NSUrlSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSError error)> _didBecomeInvalid = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinishEventsForBackgroundSession = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> _didReceiveChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSError error)> DidBecomeInvalidObs => _didBecomeInvalid; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishEventsForBackgroundSessionObs => _didFinishEventsForBackgroundSession; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> DidReceiveChallengeObs => _didReceiveChallenge; + /// + public override void DidBecomeInvalid(global::Foundation.NSUrlSession session, global::Foundation.NSError error) => _didBecomeInvalid.OnNext((session, error)); + /// + public override void DidFinishEventsForBackgroundSession(global::Foundation.NSUrlSession session) => _didFinishEventsForBackgroundSession.OnNext(session); + /// + public override void DidReceiveChallenge(global::Foundation.NSUrlSession session, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler) => _didReceiveChallenge.OnNext((session, challenge, completionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class NSUrlSessionDownloadDelegateRx : global::Foundation.NSUrlSessionDownloadDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, global::Foundation.NSUrl location)> _didFinishDownloading = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, global::Foundation.NSUrl location)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long resumeFileOffset, long expectedTotalBytes)> _didResume = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long resumeFileOffset, long expectedTotalBytes)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long bytesWritten, long totalBytesWritten, long totalBytesExpectedToWrite)> _didWriteData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long bytesWritten, long totalBytesWritten, long totalBytesExpectedToWrite)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, global::Foundation.NSUrl location)> DidFinishDownloadingObs => _didFinishDownloading; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long resumeFileOffset, long expectedTotalBytes)> DidResumeObs => _didResume; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long bytesWritten, long totalBytesWritten, long totalBytesExpectedToWrite)> DidWriteDataObs => _didWriteData; + /// + public override void DidFinishDownloading(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, global::Foundation.NSUrl location) => _didFinishDownloading.OnNext((session, downloadTask, location)); + /// + public override void DidResume(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long resumeFileOffset, long expectedTotalBytes) => _didResume.OnNext((session, downloadTask, resumeFileOffset, expectedTotalBytes)); + /// + public override void DidWriteData(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionDownloadTask downloadTask, long bytesWritten, long totalBytesWritten, long totalBytesExpectedToWrite) => _didWriteData.OnNext((session, downloadTask, bytesWritten, totalBytesWritten, totalBytesExpectedToWrite)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlSessionStreamDelegateRx : global::Foundation.NSUrlSessionStreamDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> _betterRouteDiscovered = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> _completedTaskCaptureStreams = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> _readClosed = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> _writeClosed = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> BetterRouteDiscoveredObs => _betterRouteDiscovered; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> CompletedTaskCaptureStreamsObs => _completedTaskCaptureStreams; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> ReadClosedObs => _readClosed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask)> WriteClosedObs => _writeClosed; + /// + public override void BetterRouteDiscovered(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask) => _betterRouteDiscovered.OnNext((session, streamTask)); + /// + public override void CompletedTaskCaptureStreams(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream) => _completedTaskCaptureStreams.OnNext((session, streamTask, inputStream, outputStream)); + /// + public override void ReadClosed(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask) => _readClosed.OnNext((session, streamTask)); + /// + public override void WriteClosed(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionStreamTask streamTask) => _writeClosed.OnNext((session, streamTask)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlSessionTaskDelegateRx : global::Foundation.NSUrlSessionTaskDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error)> _didCompleteWithError = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics)> _didFinishCollectingMetrics = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> _didReceiveChallenge = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend)> _didSendBodyData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler)> _needNewBodyStream = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task)> _taskIsWaitingForConnectivity = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler)> _willBeginDelayedRequest = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler)> _willPerformHttpRedirection = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error)> DidCompleteWithErrorObs => _didCompleteWithError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics)> DidFinishCollectingMetricsObs => _didFinishCollectingMetrics; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler)> DidReceiveChallengeObs => _didReceiveChallenge; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend)> DidSendBodyDataObs => _didSendBodyData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler)> NeedNewBodyStreamObs => _needNewBodyStream; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task)> TaskIsWaitingForConnectivityObs => _taskIsWaitingForConnectivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler)> WillBeginDelayedRequestObs => _willBeginDelayedRequest; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler)> WillPerformHttpRedirectionObs => _willPerformHttpRedirection; + /// + public override void DidCompleteWithError(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSError error) => _didCompleteWithError.OnNext((session, task, error)); + /// + public override void DidFinishCollectingMetrics(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlSessionTaskMetrics metrics) => _didFinishCollectingMetrics.OnNext((session, task, metrics)); + /// + public override void DidReceiveChallenge(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlAuthenticationChallenge challenge, global::System.Action completionHandler) => _didReceiveChallenge.OnNext((session, task, challenge, completionHandler)); + /// + public override void DidSendBodyData(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, long bytesSent, long totalBytesSent, long totalBytesExpectedToSend) => _didSendBodyData.OnNext((session, task, bytesSent, totalBytesSent, totalBytesExpectedToSend)); + /// + public override void NeedNewBodyStream(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::System.Action completionHandler) => _needNewBodyStream.OnNext((session, task, completionHandler)); + /// + public override void TaskIsWaitingForConnectivity(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task) => _taskIsWaitingForConnectivity.OnNext((session, task)); + /// + public override void WillBeginDelayedRequest(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSUrlRequest request, global::System.Action completionHandler) => _willBeginDelayedRequest.OnNext((session, task, request, completionHandler)); + /// + public override void WillPerformHttpRedirection(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionTask task, global::Foundation.NSHttpUrlResponse response, global::Foundation.NSUrlRequest newRequest, global::System.Action completionHandler) => _willPerformHttpRedirection.OnNext((session, task, response, newRequest, completionHandler)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUrlSessionWebSocketDelegateRx : global::Foundation.NSUrlSessionWebSocketDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, global::Foundation.NSUrlSessionWebSocketCloseCode closeCode, global::Foundation.NSData reason)> _didClose = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, global::Foundation.NSUrlSessionWebSocketCloseCode closeCode, global::Foundation.NSData reason)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, string protocol)> _didOpen = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, string protocol)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, global::Foundation.NSUrlSessionWebSocketCloseCode closeCode, global::Foundation.NSData reason)> DidCloseObs => _didClose; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, string protocol)> DidOpenObs => _didOpen; + /// + public override void DidClose(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, global::Foundation.NSUrlSessionWebSocketCloseCode closeCode, global::Foundation.NSData reason) => _didClose.OnNext((session, webSocketTask, closeCode, reason)); + /// + public override void DidOpen(global::Foundation.NSUrlSession session, global::Foundation.NSUrlSessionWebSocketTask webSocketTask, string protocol) => _didOpen.OnNext((session, webSocketTask, protocol)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class NSUserActivityDelegateRx : global::Foundation.NSUserActivityDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUserActivity userActivity, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> _userActivityReceivedData = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSUserActivity userActivity, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _userActivityWasContinued = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _userActivityWillSave = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSUserActivity userActivity, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream)> UserActivityReceivedDataObs => _userActivityReceivedData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UserActivityWasContinuedObs => _userActivityWasContinued; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UserActivityWillSaveObs => _userActivityWillSave; + /// + public override void UserActivityReceivedData(global::Foundation.NSUserActivity userActivity, global::Foundation.NSInputStream inputStream, global::Foundation.NSOutputStream outputStream) => _userActivityReceivedData.OnNext((userActivity, inputStream, outputStream)); + /// + public override void UserActivityWasContinued(global::Foundation.NSUserActivity userActivity) => _userActivityWasContinued.OnNext(userActivity); + /// + public override void UserActivityWillSave(global::Foundation.NSUserActivity userActivity) => _userActivityWillSave.OnNext(userActivity); + } +} + +namespace GameKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class GKTurnBasedEventHandlerDelegateRx : global::GameKit.GKTurnBasedEventHandlerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _handleInviteFromGameCenter = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _handleMatchEnded = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatch match, bool activated)> _handleTurnEvent = new Pharmacist.Common.SingleAwaitSubject<(global::GameKit.GKTurnBasedMatch match, bool activated)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _handleTurnEventForMatch = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable HandleInviteFromGameCenterObs => _handleInviteFromGameCenter; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable HandleMatchEndedObs => _handleMatchEnded; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::GameKit.GKTurnBasedMatch match, bool activated)> HandleTurnEventObs => _handleTurnEvent; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable HandleTurnEventForMatchObs => _handleTurnEventForMatch; + /// + public override void HandleInviteFromGameCenter(global::Foundation.NSString[] playersToInvite) => _handleInviteFromGameCenter.OnNext(playersToInvite); + /// + public override void HandleMatchEnded(global::GameKit.GKTurnBasedMatch match) => _handleMatchEnded.OnNext(match); + /// + public override void HandleTurnEvent(global::GameKit.GKTurnBasedMatch match, bool activated) => _handleTurnEvent.OnNext((match, activated)); + /// + public override void HandleTurnEventForMatch(global::GameKit.GKTurnBasedMatch match) => _handleTurnEventForMatch.OnNext(match); + } +} + +namespace HealthKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class HKLiveWorkoutBuilderDelegateRx : global::HealthKit.HKLiveWorkoutBuilderDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HealthKit.HKLiveWorkoutBuilder workoutBuilder, global::Foundation.NSSet collectedTypes)> _didCollectData = new Pharmacist.Common.SingleAwaitSubject<(global::HealthKit.HKLiveWorkoutBuilder workoutBuilder, global::Foundation.NSSet collectedTypes)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didCollectEvent = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HealthKit.HKLiveWorkoutBuilder workoutBuilder, global::Foundation.NSSet collectedTypes)> DidCollectDataObs => _didCollectData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidCollectEventObs => _didCollectEvent; + /// + public override void DidCollectData(global::HealthKit.HKLiveWorkoutBuilder workoutBuilder, global::Foundation.NSSet collectedTypes) => _didCollectData.OnNext((workoutBuilder, collectedTypes)); + /// + public override void DidCollectEvent(global::HealthKit.HKLiveWorkoutBuilder workoutBuilder) => _didCollectEvent.OnNext(workoutBuilder); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class HKWorkoutSessionDelegateRx : global::HealthKit.HKWorkoutSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HealthKit.HKWorkoutSession workoutSession, global::HealthKit.HKWorkoutSessionState toState, global::HealthKit.HKWorkoutSessionState fromState, global::Foundation.NSDate date)> _didChangeToState = new Pharmacist.Common.SingleAwaitSubject<(global::HealthKit.HKWorkoutSession workoutSession, global::HealthKit.HKWorkoutSessionState toState, global::HealthKit.HKWorkoutSessionState fromState, global::Foundation.NSDate date)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HealthKit.HKWorkoutSession workoutSession, global::Foundation.NSError error)> _didFail = new Pharmacist.Common.SingleAwaitSubject<(global::HealthKit.HKWorkoutSession workoutSession, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HealthKit.HKWorkoutSession workoutSession, global::HealthKit.HKWorkoutEvent event)> _didGenerateEvent = new Pharmacist.Common.SingleAwaitSubject<(global::HealthKit.HKWorkoutSession workoutSession, global::HealthKit.HKWorkoutEvent event)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HealthKit.HKWorkoutSession workoutSession, global::HealthKit.HKWorkoutSessionState toState, global::HealthKit.HKWorkoutSessionState fromState, global::Foundation.NSDate date)> DidChangeToStateObs => _didChangeToState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HealthKit.HKWorkoutSession workoutSession, global::Foundation.NSError error)> DidFailObs => _didFail; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HealthKit.HKWorkoutSession workoutSession, global::HealthKit.HKWorkoutEvent event)> DidGenerateEventObs => _didGenerateEvent; + /// + public override void DidChangeToState(global::HealthKit.HKWorkoutSession workoutSession, global::HealthKit.HKWorkoutSessionState toState, global::HealthKit.HKWorkoutSessionState fromState, global::Foundation.NSDate date) => _didChangeToState.OnNext((workoutSession, toState, fromState, date)); + /// + public override void DidFail(global::HealthKit.HKWorkoutSession workoutSession, global::Foundation.NSError error) => _didFail.OnNext((workoutSession, error)); + /// + public override void DidGenerateEvent(global::HealthKit.HKWorkoutSession workoutSession, global::HealthKit.HKWorkoutEvent @event) => _didGenerateEvent.OnNext((workoutSession, @event)); + } +} + +namespace HomeKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class HMAccessoryDelegateRx : global::HomeKit.HMAccessoryDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile)> _didAddProfile = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile)> _didRemoveProfile = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service)> _didUpdateAssociatedServiceType = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, string firmwareVersion)> _didUpdateFirmwareVersion = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, string firmwareVersion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateName = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service)> _didUpdateNameForService = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateReachability = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateServices = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service, global::HomeKit.HMCharacteristic characteristic)> _didUpdateValueForCharacteristic = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service, global::HomeKit.HMCharacteristic characteristic)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile)> DidAddProfileObs => _didAddProfile; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile)> DidRemoveProfileObs => _didRemoveProfile; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service)> DidUpdateAssociatedServiceTypeObs => _didUpdateAssociatedServiceType; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMAccessory accessory, string firmwareVersion)> DidUpdateFirmwareVersionObs => _didUpdateFirmwareVersion; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateNameObs => _didUpdateName; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service)> DidUpdateNameForServiceObs => _didUpdateNameForService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateReachabilityObs => _didUpdateReachability; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateServicesObs => _didUpdateServices; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service, global::HomeKit.HMCharacteristic characteristic)> DidUpdateValueForCharacteristicObs => _didUpdateValueForCharacteristic; + /// + public override void DidAddProfile(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile) => _didAddProfile.OnNext((accessory, profile)); + /// + public override void DidRemoveProfile(global::HomeKit.HMAccessory accessory, global::HomeKit.HMAccessoryProfile profile) => _didRemoveProfile.OnNext((accessory, profile)); + /// + public override void DidUpdateAssociatedServiceType(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service) => _didUpdateAssociatedServiceType.OnNext((accessory, service)); + /// + public override void DidUpdateFirmwareVersion(global::HomeKit.HMAccessory accessory, string firmwareVersion) => _didUpdateFirmwareVersion.OnNext((accessory, firmwareVersion)); + /// + public override void DidUpdateName(global::HomeKit.HMAccessory accessory) => _didUpdateName.OnNext(accessory); + /// + public override void DidUpdateNameForService(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service) => _didUpdateNameForService.OnNext((accessory, service)); + /// + public override void DidUpdateReachability(global::HomeKit.HMAccessory accessory) => _didUpdateReachability.OnNext(accessory); + /// + public override void DidUpdateServices(global::HomeKit.HMAccessory accessory) => _didUpdateServices.OnNext(accessory); + /// + public override void DidUpdateValueForCharacteristic(global::HomeKit.HMAccessory accessory, global::HomeKit.HMService service, global::HomeKit.HMCharacteristic characteristic) => _didUpdateValueForCharacteristic.OnNext((accessory, service, characteristic)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class HMCameraSnapshotControlDelegateRx : global::HomeKit.HMCameraSnapshotControlDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMCameraSnapshotControl cameraSnapshotControl, global::HomeKit.HMCameraSnapshot snapshot, global::Foundation.NSError error)> _didTakeSnapshot = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMCameraSnapshotControl cameraSnapshotControl, global::HomeKit.HMCameraSnapshot snapshot, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateMostRecentSnapshot = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMCameraSnapshotControl cameraSnapshotControl, global::HomeKit.HMCameraSnapshot snapshot, global::Foundation.NSError error)> DidTakeSnapshotObs => _didTakeSnapshot; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateMostRecentSnapshotObs => _didUpdateMostRecentSnapshot; + /// + public override void DidTakeSnapshot(global::HomeKit.HMCameraSnapshotControl cameraSnapshotControl, global::HomeKit.HMCameraSnapshot snapshot, global::Foundation.NSError error) => _didTakeSnapshot.OnNext((cameraSnapshotControl, snapshot, error)); + /// + public override void DidUpdateMostRecentSnapshot(global::HomeKit.HMCameraSnapshotControl cameraSnapshotControl) => _didUpdateMostRecentSnapshot.OnNext(cameraSnapshotControl); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class HMCameraStreamControlDelegateRx : global::HomeKit.HMCameraStreamControlDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didStartStream = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMCameraStreamControl cameraStreamControl, global::Foundation.NSError error)> _didStopStream = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMCameraStreamControl cameraStreamControl, global::Foundation.NSError error)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidStartStreamObs => _didStartStream; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMCameraStreamControl cameraStreamControl, global::Foundation.NSError error)> DidStopStreamObs => _didStopStream; + /// + public override void DidStartStream(global::HomeKit.HMCameraStreamControl cameraStreamControl) => _didStartStream.OnNext(cameraStreamControl); + /// + public override void DidStopStream(global::HomeKit.HMCameraStreamControl cameraStreamControl, global::Foundation.NSError error) => _didStopStream.OnNext((cameraStreamControl, error)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class HMHomeDelegateRx : global::HomeKit.HMHomeDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)> _didAddAccessory = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> _didAddActionSet = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)> _didAddRoom = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone)> _didAddRoomToZone = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group)> _didAddService = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)> _didAddServiceGroup = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> _didAddTrigger = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMUser user)> _didAddUser = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMUser user)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)> _didAddZone = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::Foundation.NSError error, global::HomeKit.HMAccessory accessory)> _didEncounterError = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::Foundation.NSError error, global::HomeKit.HMAccessory accessory)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)> _didRemoveAccessory = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> _didRemoveActionSet = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)> _didRemoveRoom = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone)> _didRemoveRoomFromZone = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group)> _didRemoveService = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)> _didRemoveServiceGroup = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> _didRemoveTrigger = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMUser user)> _didRemoveUser = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMUser user)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)> _didRemoveZone = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)> _didUnblockAccessory = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateAccessControlForCurrentUser = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> _didUpdateActionsForActionSet = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMHomeHubState homeHubState)> _didUpdateHomeHubState = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMHomeHubState homeHubState)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> _didUpdateNameForActionSet = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateNameForHome = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)> _didUpdateNameForRoom = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)> _didUpdateNameForServiceGroup = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> _didUpdateNameForTrigger = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)> _didUpdateNameForZone = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMAccessory accessory)> _didUpdateRoom = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMAccessory accessory)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateSupportedFeatures = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> _didUpdateTrigger = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)> DidAddAccessoryObs => _didAddAccessory; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> DidAddActionSetObs => _didAddActionSet; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)> DidAddRoomObs => _didAddRoom; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone)> DidAddRoomToZoneObs => _didAddRoomToZone; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group)> DidAddServiceObs => _didAddService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)> DidAddServiceGroupObs => _didAddServiceGroup; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> DidAddTriggerObs => _didAddTrigger; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMUser user)> DidAddUserObs => _didAddUser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)> DidAddZoneObs => _didAddZone; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::Foundation.NSError error, global::HomeKit.HMAccessory accessory)> DidEncounterErrorObs => _didEncounterError; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)> DidRemoveAccessoryObs => _didRemoveAccessory; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> DidRemoveActionSetObs => _didRemoveActionSet; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)> DidRemoveRoomObs => _didRemoveRoom; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone)> DidRemoveRoomFromZoneObs => _didRemoveRoomFromZone; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group)> DidRemoveServiceObs => _didRemoveService; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)> DidRemoveServiceGroupObs => _didRemoveServiceGroup; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> DidRemoveTriggerObs => _didRemoveTrigger; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMUser user)> DidRemoveUserObs => _didRemoveUser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)> DidRemoveZoneObs => _didRemoveZone; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory)> DidUnblockAccessoryObs => _didUnblockAccessory; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateAccessControlForCurrentUserObs => _didUpdateAccessControlForCurrentUser; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> DidUpdateActionsForActionSetObs => _didUpdateActionsForActionSet; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMHomeHubState homeHubState)> DidUpdateHomeHubStateObs => _didUpdateHomeHubState; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet)> DidUpdateNameForActionSetObs => _didUpdateNameForActionSet; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateNameForHomeObs => _didUpdateNameForHome; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room)> DidUpdateNameForRoomObs => _didUpdateNameForRoom; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group)> DidUpdateNameForServiceGroupObs => _didUpdateNameForServiceGroup; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> DidUpdateNameForTriggerObs => _didUpdateNameForTrigger; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMZone zone)> DidUpdateNameForZoneObs => _didUpdateNameForZone; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMAccessory accessory)> DidUpdateRoomObs => _didUpdateRoom; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateSupportedFeaturesObs => _didUpdateSupportedFeatures; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger)> DidUpdateTriggerObs => _didUpdateTrigger; + /// + public override void DidAddAccessory(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory) => _didAddAccessory.OnNext((home, accessory)); + /// + public override void DidAddActionSet(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet) => _didAddActionSet.OnNext((home, actionSet)); + /// + public override void DidAddRoom(global::HomeKit.HMHome home, global::HomeKit.HMRoom room) => _didAddRoom.OnNext((home, room)); + /// + public override void DidAddRoomToZone(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone) => _didAddRoomToZone.OnNext((home, room, zone)); + /// + public override void DidAddService(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group) => _didAddService.OnNext((home, service, group)); + /// + public override void DidAddServiceGroup(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group) => _didAddServiceGroup.OnNext((home, group)); + /// + public override void DidAddTrigger(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger) => _didAddTrigger.OnNext((home, trigger)); + /// + public override void DidAddUser(global::HomeKit.HMHome home, global::HomeKit.HMUser user) => _didAddUser.OnNext((home, user)); + /// + public override void DidAddZone(global::HomeKit.HMHome home, global::HomeKit.HMZone zone) => _didAddZone.OnNext((home, zone)); + /// + public override void DidEncounterError(global::HomeKit.HMHome home, global::Foundation.NSError error, global::HomeKit.HMAccessory accessory) => _didEncounterError.OnNext((home, error, accessory)); + /// + public override void DidRemoveAccessory(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory) => _didRemoveAccessory.OnNext((home, accessory)); + /// + public override void DidRemoveActionSet(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet) => _didRemoveActionSet.OnNext((home, actionSet)); + /// + public override void DidRemoveRoom(global::HomeKit.HMHome home, global::HomeKit.HMRoom room) => _didRemoveRoom.OnNext((home, room)); + /// + public override void DidRemoveRoomFromZone(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMZone zone) => _didRemoveRoomFromZone.OnNext((home, room, zone)); + /// + public override void DidRemoveService(global::HomeKit.HMHome home, global::HomeKit.HMService service, global::HomeKit.HMServiceGroup group) => _didRemoveService.OnNext((home, service, group)); + /// + public override void DidRemoveServiceGroup(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group) => _didRemoveServiceGroup.OnNext((home, group)); + /// + public override void DidRemoveTrigger(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger) => _didRemoveTrigger.OnNext((home, trigger)); + /// + public override void DidRemoveUser(global::HomeKit.HMHome home, global::HomeKit.HMUser user) => _didRemoveUser.OnNext((home, user)); + /// + public override void DidRemoveZone(global::HomeKit.HMHome home, global::HomeKit.HMZone zone) => _didRemoveZone.OnNext((home, zone)); + /// + public override void DidUnblockAccessory(global::HomeKit.HMHome home, global::HomeKit.HMAccessory accessory) => _didUnblockAccessory.OnNext((home, accessory)); + /// + public override void DidUpdateAccessControlForCurrentUser(global::HomeKit.HMHome home) => _didUpdateAccessControlForCurrentUser.OnNext(home); + /// + public override void DidUpdateActionsForActionSet(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet) => _didUpdateActionsForActionSet.OnNext((home, actionSet)); + /// + public override void DidUpdateHomeHubState(global::HomeKit.HMHome home, global::HomeKit.HMHomeHubState homeHubState) => _didUpdateHomeHubState.OnNext((home, homeHubState)); + /// + public override void DidUpdateNameForActionSet(global::HomeKit.HMHome home, global::HomeKit.HMActionSet actionSet) => _didUpdateNameForActionSet.OnNext((home, actionSet)); + /// + public override void DidUpdateNameForHome(global::HomeKit.HMHome home) => _didUpdateNameForHome.OnNext(home); + /// + public override void DidUpdateNameForRoom(global::HomeKit.HMHome home, global::HomeKit.HMRoom room) => _didUpdateNameForRoom.OnNext((home, room)); + /// + public override void DidUpdateNameForServiceGroup(global::HomeKit.HMHome home, global::HomeKit.HMServiceGroup group) => _didUpdateNameForServiceGroup.OnNext((home, group)); + /// + public override void DidUpdateNameForTrigger(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger) => _didUpdateNameForTrigger.OnNext((home, trigger)); + /// + public override void DidUpdateNameForZone(global::HomeKit.HMHome home, global::HomeKit.HMZone zone) => _didUpdateNameForZone.OnNext((home, zone)); + /// + public override void DidUpdateRoom(global::HomeKit.HMHome home, global::HomeKit.HMRoom room, global::HomeKit.HMAccessory accessory) => _didUpdateRoom.OnNext((home, room, accessory)); + /// + public override void DidUpdateSupportedFeatures(global::HomeKit.HMHome home) => _didUpdateSupportedFeatures.OnNext(home); + /// + public override void DidUpdateTrigger(global::HomeKit.HMHome home, global::HomeKit.HMTrigger trigger) => _didUpdateTrigger.OnNext((home, trigger)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class HMHomeManagerDelegateRx : global::HomeKit.HMHomeManagerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home)> _didAddHome = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home)> _didRemoveHome = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHomeManagerAuthorizationStatus status)> _didUpdateAuthorizationStatus = new Pharmacist.Common.SingleAwaitSubject<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHomeManagerAuthorizationStatus status)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateHomes = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdatePrimaryHome = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home)> DidAddHomeObs => _didAddHome; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home)> DidRemoveHomeObs => _didRemoveHome; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHomeManagerAuthorizationStatus status)> DidUpdateAuthorizationStatusObs => _didUpdateAuthorizationStatus; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateHomesObs => _didUpdateHomes; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdatePrimaryHomeObs => _didUpdatePrimaryHome; + /// + public override void DidAddHome(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home) => _didAddHome.OnNext((manager, home)); + /// + public override void DidRemoveHome(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHome home) => _didRemoveHome.OnNext((manager, home)); + /// + public override void DidUpdateAuthorizationStatus(global::HomeKit.HMHomeManager manager, global::HomeKit.HMHomeManagerAuthorizationStatus status) => _didUpdateAuthorizationStatus.OnNext((manager, status)); + /// + public override void DidUpdateHomes(global::HomeKit.HMHomeManager manager) => _didUpdateHomes.OnNext(manager); + /// + public override void DidUpdatePrimaryHome(global::HomeKit.HMHomeManager manager) => _didUpdatePrimaryHome.OnNext(manager); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class HMNetworkConfigurationProfileDelegateRx : global::HomeKit.HMNetworkConfigurationProfileDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didUpdateNetworkAccessMode = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidUpdateNetworkAccessModeObs => _didUpdateNetworkAccessMode; + /// + public override void DidUpdateNetworkAccessMode(global::HomeKit.HMNetworkConfigurationProfile profile) => _didUpdateNetworkAccessMode.OnNext(profile); + } +} + +namespace PassKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class PKPaymentAuthorizationControllerDelegateRx : global::PassKit.PKPaymentAuthorizationControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPayment payment, global::System.Action completion)> _didAuthorizePayment = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPayment payment, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinish = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::System.Action handler)> _didRequestMerchantSessionUpdate = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::System.Action handler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)> _didSelectPaymentMethod = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKContact contact, global::System.Action completion)> _didSelectShippingContact = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKContact contact, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion)> _didSelectShippingMethod = new Pharmacist.Common.SingleAwaitSubject<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _willAuthorizePayment = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPayment payment, global::System.Action completion)> DidAuthorizePaymentObs => _didAuthorizePayment; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishObs => _didFinish; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationController controller, global::System.Action handler)> DidRequestMerchantSessionUpdateObs => _didRequestMerchantSessionUpdate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion)> DidSelectPaymentMethodObs => _didSelectPaymentMethod; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKContact contact, global::System.Action completion)> DidSelectShippingContactObs => _didSelectShippingContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion)> DidSelectShippingMethodObs => _didSelectShippingMethod; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillAuthorizePaymentObs => _willAuthorizePayment; + /// + public override void DidAuthorizePayment(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPayment payment, global::System.Action completion) => _didAuthorizePayment.OnNext((controller, payment, completion)); + /// + public override void DidFinish(global::PassKit.PKPaymentAuthorizationController controller) => _didFinish.OnNext(controller); + /// + public override void DidRequestMerchantSessionUpdate(global::PassKit.PKPaymentAuthorizationController controller, global::System.Action handler) => _didRequestMerchantSessionUpdate.OnNext((controller, handler)); + /// + public override void DidSelectPaymentMethod(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKPaymentMethod paymentMethod, global::System.Action completion) => _didSelectPaymentMethod.OnNext((controller, paymentMethod, completion)); + /// + public override void DidSelectShippingContact(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKContact contact, global::System.Action completion) => _didSelectShippingContact.OnNext((controller, contact, completion)); + /// + public override void DidSelectShippingMethod(global::PassKit.PKPaymentAuthorizationController controller, global::PassKit.PKShippingMethod shippingMethod, global::System.Action completion) => _didSelectShippingMethod.OnNext((controller, shippingMethod, completion)); + /// + public override void WillAuthorizePayment(global::PassKit.PKPaymentAuthorizationController controller) => _willAuthorizePayment.OnNext(controller); + } +} + +namespace PushKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class PKPushRegistryDelegateRx : global::PushKit.PKPushRegistryDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, string type)> _didInvalidatePushToken = new Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, string type)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushPayload payload, string type, global::System.Action completion)> _didReceiveIncomingPush = new Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushPayload payload, string type, global::System.Action completion)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushCredentials credentials, string type)> _didUpdatePushCredentials = new Pharmacist.Common.SingleAwaitSubject<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushCredentials credentials, string type)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PushKit.PKPushRegistry registry, string type)> DidInvalidatePushTokenObs => _didInvalidatePushToken; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushPayload payload, string type, global::System.Action completion)> DidReceiveIncomingPushObs => _didReceiveIncomingPush; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushCredentials credentials, string type)> DidUpdatePushCredentialsObs => _didUpdatePushCredentials; + /// + public override void DidInvalidatePushToken(global::PushKit.PKPushRegistry registry, string type) => _didInvalidatePushToken.OnNext((registry, type)); + /// + public override void DidReceiveIncomingPush(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushPayload payload, string type, global::System.Action completion) => _didReceiveIncomingPush.OnNext((registry, payload, type, completion)); + /// + public override void DidUpdatePushCredentials(global::PushKit.PKPushRegistry registry, global::PushKit.PKPushCredentials credentials, string type) => _didUpdatePushCredentials.OnNext((registry, credentials, type)); + } +} + +namespace SceneKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNAvoidOccluderConstraintDelegateRx : global::SceneKit.SCNAvoidOccluderConstraintDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNAvoidOccluderConstraint constraint, global::SceneKit.SCNNode occluder, global::SceneKit.SCNNode node)> _didAvoidOccluder = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNAvoidOccluderConstraint constraint, global::SceneKit.SCNNode occluder, global::SceneKit.SCNNode node)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNAvoidOccluderConstraint constraint, global::SceneKit.SCNNode occluder, global::SceneKit.SCNNode node)> DidAvoidOccluderObs => _didAvoidOccluder; + /// + public override void DidAvoidOccluder(global::SceneKit.SCNAvoidOccluderConstraint constraint, global::SceneKit.SCNNode occluder, global::SceneKit.SCNNode node) => _didAvoidOccluder.OnNext((constraint, occluder, node)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNCameraControllerDelegateRx : global::SceneKit.SCNCameraControllerDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _cameraInertiaDidEnd = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _cameraInertiaWillStart = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable CameraInertiaDidEndObs => _cameraInertiaDidEnd; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable CameraInertiaWillStartObs => _cameraInertiaWillStart; + /// + public override void CameraInertiaDidEnd(global::SceneKit.SCNCameraController cameraController) => _cameraInertiaDidEnd.OnNext(cameraController); + /// + public override void CameraInertiaWillStart(global::SceneKit.SCNCameraController cameraController) => _cameraInertiaWillStart.OnNext(cameraController); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNPhysicsContactDelegateRx : global::SceneKit.SCNPhysicsContactDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> _didBeginContact = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> _didEndContact = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> _didUpdateContact = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> DidBeginContactObs => _didBeginContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> DidEndContactObs => _didEndContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact)> DidUpdateContactObs => _didUpdateContact; + /// + public override void DidBeginContact(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact) => _didBeginContact.OnNext((world, contact)); + /// + public override void DidEndContact(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact) => _didEndContact.OnNext((world, contact)); + /// + public override void DidUpdateContact(global::SceneKit.SCNPhysicsWorld world, global::SceneKit.SCNPhysicsContact contact) => _didUpdateContact.OnNext((world, contact)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SCNSceneRendererDelegateRx : global::SceneKit.SCNSceneRendererDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> _didApplyAnimations = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double atTime)> _didApplyConstraints = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double atTime)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> _didRenderScene = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> _didSimulatePhysics = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> _update = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> _willRenderScene = new Pharmacist.Common.SingleAwaitSubject<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> DidApplyAnimationsObs => _didApplyAnimations; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double atTime)> DidApplyConstraintsObs => _didApplyConstraints; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> DidRenderSceneObs => _didRenderScene; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> DidSimulatePhysicsObs => _didSimulatePhysics; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds)> UpdateObs => _update; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds)> WillRenderSceneObs => _willRenderScene; + /// + public override void DidApplyAnimations(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds) => _didApplyAnimations.OnNext((renderer, timeInSeconds)); + /// + public override void DidApplyConstraints(global::SceneKit.ISCNSceneRenderer renderer, double atTime) => _didApplyConstraints.OnNext((renderer, atTime)); + /// + public override void DidRenderScene(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds) => _didRenderScene.OnNext((renderer, scene, timeInSeconds)); + /// + public override void DidSimulatePhysics(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds) => _didSimulatePhysics.OnNext((renderer, timeInSeconds)); + /// + public override void Update(global::SceneKit.ISCNSceneRenderer renderer, double timeInSeconds) => _update.OnNext((renderer, timeInSeconds)); + /// + public override void WillRenderScene(global::SceneKit.ISCNSceneRenderer renderer, global::SceneKit.SCNScene scene, double timeInSeconds) => _willRenderScene.OnNext((renderer, scene, timeInSeconds)); + } +} + +namespace SpriteKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class SKPhysicsContactDelegateRx : global::SpriteKit.SKPhysicsContactDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didBeginContact = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEndContact = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidBeginContactObs => _didBeginContact; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEndContactObs => _didEndContact; + /// + public override void DidBeginContact(global::SpriteKit.SKPhysicsContact contact) => _didBeginContact.OnNext(contact); + /// + public override void DidEndContact(global::SpriteKit.SKPhysicsContact contact) => _didEndContact.OnNext(contact); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SKSceneDelegateRx : global::SpriteKit.SKSceneDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _didApplyConstraints = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didEvaluateActions = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFinishUpdate = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didSimulatePhysics = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(double currentTime, global::SpriteKit.SKScene scene)> _update = new Pharmacist.Common.SingleAwaitSubject<(double currentTime, global::SpriteKit.SKScene scene)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidApplyConstraintsObs => _didApplyConstraints; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidEvaluateActionsObs => _didEvaluateActions; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFinishUpdateObs => _didFinishUpdate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidSimulatePhysicsObs => _didSimulatePhysics; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(double currentTime, global::SpriteKit.SKScene scene)> UpdateObs => _update; + /// + public override void DidApplyConstraints(global::SpriteKit.SKScene scene) => _didApplyConstraints.OnNext(scene); + /// + public override void DidEvaluateActions(global::SpriteKit.SKScene scene) => _didEvaluateActions.OnNext(scene); + /// + public override void DidFinishUpdate(global::SpriteKit.SKScene scene) => _didFinishUpdate.OnNext(scene); + /// + public override void DidSimulatePhysics(global::SpriteKit.SKScene scene) => _didSimulatePhysics.OnNext(scene); + /// + public override void Update(double currentTime, global::SpriteKit.SKScene scene) => _update.OnNext((currentTime, scene)); + } +} + +namespace StoreKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class SKProductsRequestDelegateRx : global::StoreKit.SKProductsRequestDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKProductsRequest request, global::StoreKit.SKProductsResponse response)> _receivedResponse = new Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKProductsRequest request, global::StoreKit.SKProductsResponse response)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::StoreKit.SKProductsRequest request, global::StoreKit.SKProductsResponse response)> ReceivedResponseObs => _receivedResponse; + /// + public override void ReceivedResponse(global::StoreKit.SKProductsRequest request, global::StoreKit.SKProductsResponse response) => _receivedResponse.OnNext((request, response)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class SKRequestDelegateRx : global::StoreKit.SKRequestDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKRequest request, global::Foundation.NSError error)> _requestFailed = new Pharmacist.Common.SingleAwaitSubject<(global::StoreKit.SKRequest request, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _requestFinished = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::StoreKit.SKRequest request, global::Foundation.NSError error)> RequestFailedObs => _requestFailed; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable RequestFinishedObs => _requestFinished; + /// + public override void RequestFailed(global::StoreKit.SKRequest request, global::Foundation.NSError error) => _requestFailed.OnNext((request, error)); + /// + public override void RequestFinished(global::StoreKit.SKRequest request) => _requestFinished.OnNext(request); + } +} + +namespace UserNotifications +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class UNUserNotificationCenterDelegateRx : global::UserNotifications.UNUserNotificationCenterDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotificationResponse response, global::System.Action completionHandler)> _didReceiveNotificationResponse = new Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotificationResponse response, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification, global::System.Action completionHandler)> _willPresentNotification = new Pharmacist.Common.SingleAwaitSubject<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification, global::System.Action completionHandler)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotificationResponse response, global::System.Action completionHandler)> DidReceiveNotificationResponseObs => _didReceiveNotificationResponse; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification, global::System.Action completionHandler)> WillPresentNotificationObs => _willPresentNotification; + /// + public override void DidReceiveNotificationResponse(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotificationResponse response, global::System.Action completionHandler) => _didReceiveNotificationResponse.OnNext((center, response, completionHandler)); + /// + public override void WillPresentNotification(global::UserNotifications.UNUserNotificationCenter center, global::UserNotifications.UNNotification notification, global::System.Action completionHandler) => _willPresentNotification.OnNext((center, notification, completionHandler)); + } +} + +namespace WatchConnectivity +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class WCSessionDelegateRx : global::WatchConnectivity.WCSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionActivationState activationState, global::Foundation.NSError error)> _activationDidComplete = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionActivationState activationState, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _companionAppInstalledDidChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFileTransfer fileTransfer, global::Foundation.NSError error)> _didFinishFileTransfer = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFileTransfer fileTransfer, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionUserInfoTransfer userInfoTransfer, global::Foundation.NSError error)> _didFinishUserInfoTransfer = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionUserInfoTransfer userInfoTransfer, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary applicationContext)> _didReceiveApplicationContext = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary applicationContext)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFile file)> _didReceiveFile = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFile file)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary message, global::WatchConnectivity.WCSessionReplyHandler replyHandler)> _didReceiveMessage = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary message, global::WatchConnectivity.WCSessionReplyHandler replyHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSData messageData, global::WatchConnectivity.WCSessionReplyDataHandler replyHandler)> _didReceiveMessageData = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSData messageData, global::WatchConnectivity.WCSessionReplyDataHandler replyHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary userInfo)> _didReceiveUserInfo = new Pharmacist.Common.SingleAwaitSubject<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary userInfo)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _sessionReachabilityDidChange = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionActivationState activationState, global::Foundation.NSError error)> ActivationDidCompleteObs => _activationDidComplete; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable CompanionAppInstalledDidChangeObs => _companionAppInstalledDidChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFileTransfer fileTransfer, global::Foundation.NSError error)> DidFinishFileTransferObs => _didFinishFileTransfer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionUserInfoTransfer userInfoTransfer, global::Foundation.NSError error)> DidFinishUserInfoTransferObs => _didFinishUserInfoTransfer; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary applicationContext)> DidReceiveApplicationContextObs => _didReceiveApplicationContext; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFile file)> DidReceiveFileObs => _didReceiveFile; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary message, global::WatchConnectivity.WCSessionReplyHandler replyHandler)> DidReceiveMessageObs => _didReceiveMessage; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::Foundation.NSData messageData, global::WatchConnectivity.WCSessionReplyDataHandler replyHandler)> DidReceiveMessageDataObs => _didReceiveMessageData; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary userInfo)> DidReceiveUserInfoObs => _didReceiveUserInfo; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable SessionReachabilityDidChangeObs => _sessionReachabilityDidChange; + /// + public override void ActivationDidComplete(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionActivationState activationState, global::Foundation.NSError error) => _activationDidComplete.OnNext((session, activationState, error)); + /// + public override void CompanionAppInstalledDidChange(global::WatchConnectivity.WCSession session) => _companionAppInstalledDidChange.OnNext(session); + /// + public override void DidFinishFileTransfer(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFileTransfer fileTransfer, global::Foundation.NSError error) => _didFinishFileTransfer.OnNext((session, fileTransfer, error)); + /// + public override void DidFinishUserInfoTransfer(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionUserInfoTransfer userInfoTransfer, global::Foundation.NSError error) => _didFinishUserInfoTransfer.OnNext((session, userInfoTransfer, error)); + /// + public override void DidReceiveApplicationContext(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary applicationContext) => _didReceiveApplicationContext.OnNext((session, applicationContext)); + /// + public override void DidReceiveFile(global::WatchConnectivity.WCSession session, global::WatchConnectivity.WCSessionFile file) => _didReceiveFile.OnNext((session, file)); + /// + public override void DidReceiveMessage(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary message, global::WatchConnectivity.WCSessionReplyHandler replyHandler) => _didReceiveMessage.OnNext((session, message, replyHandler)); + /// + public override void DidReceiveMessageData(global::WatchConnectivity.WCSession session, global::Foundation.NSData messageData, global::WatchConnectivity.WCSessionReplyDataHandler replyHandler) => _didReceiveMessageData.OnNext((session, messageData, replyHandler)); + /// + public override void DidReceiveUserInfo(global::WatchConnectivity.WCSession session, global::Foundation.NSDictionary userInfo) => _didReceiveUserInfo.OnNext((session, userInfo)); + /// + public override void SessionReachabilityDidChange(global::WatchConnectivity.WCSession session) => _sessionReachabilityDidChange.OnNext(session); + } +} + +namespace WatchKit +{ + /// + /// Wraps delegates events from into Observables. + /// + public partial class WKCrownDelegateRx : global::WatchKit.WKCrownDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _crownDidBecomeIdle = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchKit.WKCrownSequencer crownSequencer, double rotationalDelta)> _crownDidRotate = new Pharmacist.Common.SingleAwaitSubject<(global::WatchKit.WKCrownSequencer crownSequencer, double rotationalDelta)>(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable CrownDidBecomeIdleObs => _crownDidBecomeIdle; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchKit.WKCrownSequencer crownSequencer, double rotationalDelta)> CrownDidRotateObs => _crownDidRotate; + /// + public override void CrownDidBecomeIdle(global::WatchKit.WKCrownSequencer crownSequencer) => _crownDidBecomeIdle.OnNext(crownSequencer); + /// + public override void CrownDidRotate(global::WatchKit.WKCrownSequencer crownSequencer, double rotationalDelta) => _crownDidRotate.OnNext((crownSequencer, rotationalDelta)); + } + + /// + /// Wraps delegates events from into Observables. + /// + public abstract partial class WKExtendedRuntimeSessionDelegateRx : global::WatchKit.WKExtendedRuntimeSessionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject<(global::WatchKit.WKExtendedRuntimeSession extendedRuntimeSession, global::WatchKit.WKExtendedRuntimeSessionInvalidationReason reason, global::Foundation.NSError error)> _didInvalidate = new Pharmacist.Common.SingleAwaitSubject<(global::WatchKit.WKExtendedRuntimeSession extendedRuntimeSession, global::WatchKit.WKExtendedRuntimeSessionInvalidationReason reason, global::Foundation.NSError error)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didStart = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _willExpire = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::WatchKit.WKExtendedRuntimeSession extendedRuntimeSession, global::WatchKit.WKExtendedRuntimeSessionInvalidationReason reason, global::Foundation.NSError error)> DidInvalidateObs => _didInvalidate; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidStartObs => _didStart; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable WillExpireObs => _willExpire; + /// + public override void DidInvalidate(global::WatchKit.WKExtendedRuntimeSession extendedRuntimeSession, global::WatchKit.WKExtendedRuntimeSessionInvalidationReason reason, global::Foundation.NSError error) => _didInvalidate.OnNext((extendedRuntimeSession, reason, error)); + /// + public override void DidStart(global::WatchKit.WKExtendedRuntimeSession extendedRuntimeSession) => _didStart.OnNext(extendedRuntimeSession); + /// + public override void WillExpire(global::WatchKit.WKExtendedRuntimeSession extendedRuntimeSession) => _willExpire.OnNext(extendedRuntimeSession); + } + + /// + /// Wraps delegates events from into Observables. + /// + public partial class WKExtensionDelegateRx : global::WatchKit.WKExtensionDelegate + { + private readonly Pharmacist.Common.SingleAwaitSubject _applicationDidBecomeActive = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _applicationDidEnterBackground = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _applicationDidFinishLaunching = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _applicationWillEnterForeground = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _applicationWillResignActive = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _deviceOrientationDidChange = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didFailToRegisterForRemoteNotifications = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _didReceiveLocalNotification = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSDictionary userInfo, global::System.Action completionHandler)> _didReceiveRemoteNotification = new Pharmacist.Common.SingleAwaitSubject<(global::Foundation.NSDictionary userInfo, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _didRegisterForRemoteNotifications = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(string identifier, global::Foundation.NSDictionary remoteNotification, global::Foundation.NSDictionary responseInfo)> _handleAction = new Pharmacist.Common.SingleAwaitSubject<(string identifier, global::Foundation.NSDictionary remoteNotification, global::Foundation.NSDictionary responseInfo)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _handleActiveWorkoutRecovery = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject> _handleBackgroundTasks = new Pharmacist.Common.SingleAwaitSubject>(); + private readonly Pharmacist.Common.SingleAwaitSubject _handleExtendedRuntimeSession = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject<(global::Intents.INIntent intent, global::System.Action completionHandler)> _handleIntent = new Pharmacist.Common.SingleAwaitSubject<(global::Intents.INIntent intent, global::System.Action completionHandler)>(); + private readonly Pharmacist.Common.SingleAwaitSubject _handleRemoteNowPlayingActivity = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _handleUserActivity = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _handleWorkoutConfiguration = new Pharmacist.Common.SingleAwaitSubject(); + private readonly Pharmacist.Common.SingleAwaitSubject _userDidAcceptCloudKitShare = new Pharmacist.Common.SingleAwaitSubject(); + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ApplicationDidBecomeActiveObs => _applicationDidBecomeActive; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ApplicationDidEnterBackgroundObs => _applicationDidEnterBackground; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ApplicationDidFinishLaunchingObs => _applicationDidFinishLaunching; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ApplicationWillEnterForegroundObs => _applicationWillEnterForeground; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable ApplicationWillResignActiveObs => _applicationWillResignActive; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DeviceOrientationDidChangeObs => _deviceOrientationDidChange; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidFailToRegisterForRemoteNotificationsObs => _didFailToRegisterForRemoteNotifications; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidReceiveLocalNotificationObs => _didReceiveLocalNotification; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Foundation.NSDictionary userInfo, global::System.Action completionHandler)> DidReceiveRemoteNotificationObs => _didReceiveRemoteNotification; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable DidRegisterForRemoteNotificationsObs => _didRegisterForRemoteNotifications; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(string identifier, global::Foundation.NSDictionary remoteNotification, global::Foundation.NSDictionary responseInfo)> HandleActionObs => _handleAction; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable HandleActiveWorkoutRecoveryObs => _handleActiveWorkoutRecovery; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable> HandleBackgroundTasksObs => _handleBackgroundTasks; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable HandleExtendedRuntimeSessionObs => _handleExtendedRuntimeSession; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable<(global::Intents.INIntent intent, global::System.Action completionHandler)> HandleIntentObs => _handleIntent; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable HandleRemoteNowPlayingActivityObs => _handleRemoteNowPlayingActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable HandleUserActivityObs => _handleUserActivity; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable HandleWorkoutConfigurationObs => _handleWorkoutConfiguration; + /// + /// Gets an observable which signals when the method is invoked. + /// + public global::System.IObservable UserDidAcceptCloudKitShareObs => _userDidAcceptCloudKitShare; + /// + public override void ApplicationDidBecomeActive() => _applicationDidBecomeActive.OnNext(global::System.Reactive.Unit.Default); + /// + public override void ApplicationDidEnterBackground() => _applicationDidEnterBackground.OnNext(global::System.Reactive.Unit.Default); + /// + public override void ApplicationDidFinishLaunching() => _applicationDidFinishLaunching.OnNext(global::System.Reactive.Unit.Default); + /// + public override void ApplicationWillEnterForeground() => _applicationWillEnterForeground.OnNext(global::System.Reactive.Unit.Default); + /// + public override void ApplicationWillResignActive() => _applicationWillResignActive.OnNext(global::System.Reactive.Unit.Default); + /// + public override void DeviceOrientationDidChange() => _deviceOrientationDidChange.OnNext(global::System.Reactive.Unit.Default); + /// + public override void DidFailToRegisterForRemoteNotifications(global::Foundation.NSError error) => _didFailToRegisterForRemoteNotifications.OnNext(error); + /// + public override void DidReceiveLocalNotification(global::UIKit.UILocalNotification notification) => _didReceiveLocalNotification.OnNext(notification); + /// + public override void DidReceiveRemoteNotification(global::Foundation.NSDictionary userInfo, global::System.Action completionHandler) => _didReceiveRemoteNotification.OnNext((userInfo, completionHandler)); + /// + public override void DidRegisterForRemoteNotifications(global::Foundation.NSData deviceToken) => _didRegisterForRemoteNotifications.OnNext(deviceToken); + /// + public override void HandleAction(string identifier, global::Foundation.NSDictionary remoteNotification, global::Foundation.NSDictionary responseInfo) => _handleAction.OnNext((identifier, remoteNotification, responseInfo)); + /// + public override void HandleActiveWorkoutRecovery() => _handleActiveWorkoutRecovery.OnNext(global::System.Reactive.Unit.Default); + /// + public override void HandleBackgroundTasks(global::Foundation.NSSet backgroundTasks) => _handleBackgroundTasks.OnNext(backgroundTasks); + /// + public override void HandleExtendedRuntimeSession(global::WatchKit.WKExtendedRuntimeSession extendedRuntimeSession) => _handleExtendedRuntimeSession.OnNext(extendedRuntimeSession); + /// + public override void HandleIntent(global::Intents.INIntent intent, global::System.Action completionHandler) => _handleIntent.OnNext((intent, completionHandler)); + /// + public override void HandleRemoteNowPlayingActivity() => _handleRemoteNowPlayingActivity.OnNext(global::System.Reactive.Unit.Default); + /// + public override void HandleUserActivity(global::Foundation.NSDictionary userInfo) => _handleUserActivity.OnNext(userInfo); + /// + public override void HandleWorkoutConfiguration(global::HealthKit.HKWorkoutConfiguration workoutConfiguration) => _handleWorkoutConfiguration.OnNext(workoutConfiguration); + /// + public override void UserDidAcceptCloudKitShare(global::CloudKit.CKShareMetadata cloudKitShareMetadata) => _userDidAcceptCloudKitShare.OnNext(cloudKitShareMetadata); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Tizen.NET.API4.1.0.0.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Tizen.NET.API4.1.0.0.netstandard2.0.approved.txt deleted file mode 100644 index e69de29..0000000 diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Tizen.NET.API4.4.0.1.14152.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Tizen.NET.API4.4.0.1.14152.netstandard2.0.approved.txt index 25db7a8..f2adef8 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Tizen.NET.API4.4.0.1.14152.netstandard2.0.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Tizen.NET.API4.4.0.1.14152.netstandard2.0.approved.txt @@ -204,9 +204,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -214,9 +212,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -224,9 +220,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -234,9 +228,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Repeated += x, x => _data.Repeated -= x); + }, x => _data.Repeated += x, x => _data.Repeated -= x); } /// @@ -261,9 +253,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateChanged += x, x => _data.DateChanged -= x); + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -271,9 +261,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.DisplayedMonthChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayedMonthChanged += x, x => _data.DisplayedMonthChanged -= x); + }, x => _data.DisplayedMonthChanged += x, x => _data.DisplayedMonthChanged -= x); } /// @@ -298,9 +286,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.CheckStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -325,9 +311,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.ColorChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); } /// @@ -352,9 +336,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); } /// @@ -379,9 +361,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } /// @@ -406,9 +386,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); + }, x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); } /// @@ -433,9 +411,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Finished += x, x => _data.Finished -= x); + }, x => _data.Finished += x, x => _data.Finished -= x); } /// @@ -460,9 +436,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EffectEnded += x, x => _data.EffectEnded -= x); + }, x => _data.EffectEnded += x, x => _data.EffectEnded -= x); } /// @@ -487,9 +461,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -497,9 +469,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChangedByUser += x, x => _data.ChangedByUser -= x); + }, x => _data.ChangedByUser += x, x => _data.ChangedByUser -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -507,9 +477,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -517,9 +485,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); } /// @@ -544,9 +510,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -554,9 +518,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Deleted += x, x => _data.Deleted -= x); + }, x => _data.Deleted += x, x => _data.Deleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -564,9 +526,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -574,9 +534,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -584,9 +542,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MoreButtonPressed += x, x => _data.MoreButtonPressed -= x); + }, x => _data.MoreButtonPressed += x, x => _data.MoreButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -594,9 +550,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Moved += x, x => _data.Moved -= x); + }, x => _data.Moved += x, x => _data.Moved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -604,9 +558,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RenderPost += x, x => _data.RenderPost -= x); + }, x => _data.RenderPost += x, x => _data.RenderPost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -614,9 +566,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resized += x, x => _data.Resized -= x); + }, x => _data.Resized += x, x => _data.Resized -= x); } /// @@ -641,9 +591,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.On += x, x => _data.On -= x); + }, x => _data.On += x, x => _data.On -= x); } /// @@ -668,9 +616,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Overflowed += x, x => _data.Overflowed -= x); + }, x => _data.Overflowed += x, x => _data.Overflowed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -678,9 +624,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -688,9 +632,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Underflowed += x, x => _data.Underflowed -= x); + }, x => _data.Underflowed += x, x => _data.Underflowed -= x); } /// @@ -715,9 +657,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } /// @@ -742,9 +682,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -752,9 +690,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemActivated += x, x => _data.ItemActivated -= x); + }, x => _data.ItemActivated += x, x => _data.ItemActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -762,9 +698,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDoubleClicked += x, x => _data.ItemDoubleClicked -= x); + }, x => _data.ItemDoubleClicked += x, x => _data.ItemDoubleClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -772,9 +706,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -782,9 +714,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemPressed += x, x => _data.ItemPressed -= x); + }, x => _data.ItemPressed += x, x => _data.ItemPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -792,9 +722,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemRealized += x, x => _data.ItemRealized -= x); + }, x => _data.ItemRealized += x, x => _data.ItemRealized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -802,9 +730,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemReleased += x, x => _data.ItemReleased -= x); + }, x => _data.ItemReleased += x, x => _data.ItemReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -812,9 +738,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -822,9 +746,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemUnrealized += x, x => _data.ItemUnrealized -= x); + }, x => _data.ItemUnrealized += x, x => _data.ItemUnrealized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -832,9 +754,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemUnselected += x, x => _data.ItemUnselected -= x); + }, x => _data.ItemUnselected += x, x => _data.ItemUnselected -= x); } /// @@ -859,9 +779,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -869,9 +787,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemActivated += x, x => _data.ItemActivated -= x); + }, x => _data.ItemActivated += x, x => _data.ItemActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -879,9 +795,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDoubleClicked += x, x => _data.ItemDoubleClicked -= x); + }, x => _data.ItemDoubleClicked += x, x => _data.ItemDoubleClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -889,9 +803,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemExpanded += x, x => _data.ItemExpanded -= x); + }, x => _data.ItemExpanded += x, x => _data.ItemExpanded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -899,9 +811,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -909,9 +819,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemMoved += x, x => _data.ItemMoved -= x); + }, x => _data.ItemMoved += x, x => _data.ItemMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -919,9 +827,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemMovedAfter += x, x => _data.ItemMovedAfter -= x); + }, x => _data.ItemMovedAfter += x, x => _data.ItemMovedAfter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -929,9 +835,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemMovedBefore += x, x => _data.ItemMovedBefore -= x); + }, x => _data.ItemMovedBefore += x, x => _data.ItemMovedBefore -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -939,9 +843,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemPressed += x, x => _data.ItemPressed -= x); + }, x => _data.ItemPressed += x, x => _data.ItemPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -949,9 +851,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemRealized += x, x => _data.ItemRealized -= x); + }, x => _data.ItemRealized += x, x => _data.ItemRealized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -959,9 +859,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemReleased += x, x => _data.ItemReleased -= x); + }, x => _data.ItemReleased += x, x => _data.ItemReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -969,9 +867,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -979,9 +875,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemUnrealized += x, x => _data.ItemUnrealized -= x); + }, x => _data.ItemUnrealized += x, x => _data.ItemUnrealized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -989,9 +883,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemUnselected += x, x => _data.ItemUnselected -= x); + }, x => _data.ItemUnselected += x, x => _data.ItemUnselected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -999,9 +891,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollAnimationStarted += x, x => _data.ScrollAnimationStarted -= x); + }, x => _data.ScrollAnimationStarted += x, x => _data.ScrollAnimationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1009,9 +899,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollAnimationStopped += x, x => _data.ScrollAnimationStopped -= x); + }, x => _data.ScrollAnimationStopped += x, x => _data.ScrollAnimationStopped -= x); } /// @@ -1036,9 +924,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1046,9 +932,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1056,9 +940,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Expanded += x, x => _data.Expanded -= x); + }, x => _data.Expanded += x, x => _data.Expanded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1066,9 +948,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.HoverselItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -1093,9 +973,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -1120,9 +998,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1130,9 +1006,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadingCompleted += x, x => _data.LoadingCompleted -= x); + }, x => _data.LoadingCompleted += x, x => _data.LoadingCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1140,9 +1014,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadingFailed += x, x => _data.LoadingFailed -= x); + }, x => _data.LoadingFailed += x, x => _data.LoadingFailed -= x); } /// @@ -1167,9 +1039,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } /// @@ -1194,9 +1064,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } /// @@ -1221,9 +1089,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Deleted += x, x => _data.Deleted -= x); + }, x => _data.Deleted += x, x => _data.Deleted -= x); } /// @@ -1248,9 +1114,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SlideCompleted += x, x => _data.SlideCompleted -= x); + }, x => _data.SlideCompleted += x, x => _data.SlideCompleted -= x); } /// @@ -1275,9 +1139,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); + }, x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1285,9 +1147,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ThemeChanged += x, x => _data.ThemeChanged -= x); + }, x => _data.ThemeChanged += x, x => _data.ThemeChanged -= x); } /// @@ -1312,9 +1172,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.ListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemActivated += x, x => _data.ItemActivated -= x); + }, x => _data.ItemActivated += x, x => _data.ItemActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1322,9 +1180,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.ListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDoubleClicked += x, x => _data.ItemDoubleClicked -= x); + }, x => _data.ItemDoubleClicked += x, x => _data.ItemDoubleClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1332,9 +1188,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.ListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1342,9 +1196,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.ListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1352,9 +1204,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.ListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemUnselected += x, x => _data.ItemUnselected -= x); + }, x => _data.ItemUnselected += x, x => _data.ItemUnselected -= x); } /// @@ -1379,9 +1229,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1389,9 +1237,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Contracted += x, x => _data.Contracted -= x); + }, x => _data.Contracted += x, x => _data.Contracted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1399,9 +1245,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Expanded += x, x => _data.Expanded -= x); + }, x => _data.Expanded += x, x => _data.Expanded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1409,9 +1253,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ExpandedStateChanged += x, x => _data.ExpandedStateChanged -= x); + }, x => _data.ExpandedStateChanged += x, x => _data.ExpandedStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1419,9 +1261,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.MultiButtonEntryItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1429,9 +1269,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.MultiButtonEntryItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1439,9 +1277,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.MultiButtonEntryItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDeleted += x, x => _data.ItemDeleted -= x); + }, x => _data.ItemDeleted += x, x => _data.ItemDeleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1449,9 +1285,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.MultiButtonEntryItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1459,9 +1293,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.MultiButtonEntryItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -1486,9 +1318,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); + }, x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1496,9 +1326,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.NaviframeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); } /// @@ -1523,9 +1351,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); } /// @@ -1550,9 +1376,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -1577,9 +1401,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1587,9 +1409,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unpressed += x, x => _data.Unpressed -= x); + }, x => _data.Unpressed += x, x => _data.Unpressed -= x); } /// @@ -1614,9 +1434,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1624,9 +1442,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OutsideClicked += x, x => _data.OutsideClicked -= x); + }, x => _data.OutsideClicked += x, x => _data.OutsideClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1634,9 +1450,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ShowAnimationFinished += x, x => _data.ShowAnimationFinished -= x); + }, x => _data.ShowAnimationFinished += x, x => _data.ShowAnimationFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1644,9 +1458,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TimedOut += x, x => _data.TimedOut -= x); + }, x => _data.TimedOut += x, x => _data.TimedOut -= x); } /// @@ -1671,9 +1483,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -1698,9 +1508,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -1725,9 +1533,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStart += x, x => _data.DragStart -= x); + }, x => _data.DragStart += x, x => _data.DragStart -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1735,9 +1541,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStop += x, x => _data.DragStop -= x); + }, x => _data.DragStop += x, x => _data.DragStop -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1745,9 +1549,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PageScrolled += x, x => _data.PageScrolled -= x); + }, x => _data.PageScrolled += x, x => _data.PageScrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1755,9 +1557,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); } /// @@ -1782,9 +1582,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DelayedValueChanged += x, x => _data.DelayedValueChanged -= x); + }, x => _data.DelayedValueChanged += x, x => _data.DelayedValueChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1792,9 +1590,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1802,9 +1598,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStopped += x, x => _data.DragStopped -= x); + }, x => _data.DragStopped += x, x => _data.DragStopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1812,9 +1606,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -1839,9 +1631,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.On += x, x => _data.On -= x); + }, x => _data.On += x, x => _data.On -= x); } /// @@ -1866,9 +1656,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DelayedValueChanged += x, x => _data.DelayedValueChanged -= x); + }, x => _data.DelayedValueChanged += x, x => _data.DelayedValueChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1876,9 +1664,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -1903,9 +1689,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.ToolbarItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } /// @@ -1930,9 +1714,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1940,9 +1722,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LongPressed += x, x => _data.LongPressed -= x); + }, x => _data.LongPressed += x, x => _data.LongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1950,9 +1730,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } /// @@ -1977,9 +1755,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Deleted += x, x => _data.Deleted -= x); + }, x => _data.Deleted += x, x => _data.Deleted -= x); } /// @@ -2004,9 +1780,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2014,9 +1788,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2041,9 +1813,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2051,9 +1821,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RotationChanged += x, x => _data.RotationChanged -= x); + }, x => _data.RotationChanged += x, x => _data.RotationChanged -= x); } } @@ -2100,9 +1868,7 @@ namespace ElmSharp.Wearable { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2127,9 +1893,7 @@ namespace ElmSharp.Wearable { void Handler(object sender, global::ElmSharp.Wearable.MoreOptionItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2137,9 +1901,7 @@ namespace ElmSharp.Wearable { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2147,9 +1909,7 @@ namespace ElmSharp.Wearable { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2157,9 +1917,7 @@ namespace ElmSharp.Wearable { void Handler(object sender, global::ElmSharp.Wearable.MoreOptionItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } /// @@ -2184,9 +1942,7 @@ namespace ElmSharp.Wearable { void Handler(object sender, global::ElmSharp.Wearable.RotarySelectorItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2194,9 +1950,7 @@ namespace ElmSharp.Wearable { void Handler(object sender, global::ElmSharp.Wearable.RotarySelectorItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } } @@ -2251,9 +2005,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.AppControlReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AppControlReceived += x, x => _data.AppControlReceived -= x); + }, x => _data.AppControlReceived += x, x => _data.AppControlReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2261,9 +2013,7 @@ namespace Tizen.Applications { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Created += x, x => _data.Created -= x); + }, x => _data.Created += x, x => _data.Created -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2271,9 +2021,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.DeviceOrientationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DeviceOrientationChanged += x, x => _data.DeviceOrientationChanged -= x); + }, x => _data.DeviceOrientationChanged += x, x => _data.DeviceOrientationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2281,9 +2029,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.LocaleChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LocaleChanged += x, x => _data.LocaleChanged -= x); + }, x => _data.LocaleChanged += x, x => _data.LocaleChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2291,9 +2037,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.LowBatteryEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LowBattery += x, x => _data.LowBattery -= x); + }, x => _data.LowBattery += x, x => _data.LowBattery -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2301,9 +2045,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.LowMemoryEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LowMemory += x, x => _data.LowMemory -= x); + }, x => _data.LowMemory += x, x => _data.LowMemory -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2311,9 +2053,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.RegionFormatChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RegionFormatChanged += x, x => _data.RegionFormatChanged -= x); + }, x => _data.RegionFormatChanged += x, x => _data.RegionFormatChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2321,9 +2061,7 @@ namespace Tizen.Applications { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Terminated += x, x => _data.Terminated -= x); + }, x => _data.Terminated += x, x => _data.Terminated -= x); } /// @@ -2348,9 +2086,7 @@ namespace Tizen.Applications { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paused += x, x => _data.Paused -= x); + }, x => _data.Paused += x, x => _data.Paused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2358,9 +2094,7 @@ namespace Tizen.Applications { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resumed += x, x => _data.Resumed -= x); + }, x => _data.Resumed += x, x => _data.Resumed -= x); } /// @@ -2385,9 +2119,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.PreferenceChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } /// @@ -2412,9 +2144,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.AmbientEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AmbientChanged += x, x => _data.AmbientChanged -= x); + }, x => _data.AmbientChanged += x, x => _data.AmbientChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2422,9 +2152,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.TimeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AmbientTick += x, x => _data.AmbientTick -= x); + }, x => _data.AmbientTick += x, x => _data.AmbientTick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2432,9 +2160,7 @@ namespace Tizen.Applications { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paused += x, x => _data.Paused -= x); + }, x => _data.Paused += x, x => _data.Paused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2442,9 +2168,7 @@ namespace Tizen.Applications { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resumed += x, x => _data.Resumed -= x); + }, x => _data.Resumed += x, x => _data.Resumed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2452,9 +2176,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.TimeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TimeTick += x, x => _data.TimeTick -= x); + }, x => _data.TimeTick += x, x => _data.TimeTick -= x); } /// @@ -2479,9 +2201,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.WidgetLifecycleEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Created += x, x => _data.Created -= x); + }, x => _data.Created += x, x => _data.Created -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2489,9 +2209,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.WidgetLifecycleEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2499,9 +2217,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.WidgetLifecycleEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paused += x, x => _data.Paused -= x); + }, x => _data.Paused += x, x => _data.Paused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2509,9 +2225,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.WidgetLifecycleEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resumed += x, x => _data.Resumed -= x); + }, x => _data.Resumed += x, x => _data.Resumed -= x); } } @@ -2550,9 +2264,7 @@ namespace Tizen.Applications.AttachPanel { void Handler(object sender, global::Tizen.Applications.AttachPanel.StateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EventChanged += x, x => _data.EventChanged -= x); + }, x => _data.EventChanged += x, x => _data.EventChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2560,9 +2272,7 @@ namespace Tizen.Applications.AttachPanel { void Handler(object sender, global::Tizen.Applications.AttachPanel.ResultEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResultCallback += x, x => _data.ResultCallback -= x); + }, x => _data.ResultCallback += x, x => _data.ResultCallback -= x); } } @@ -2605,9 +2315,7 @@ namespace Tizen.Applications.Messages { void Handler(object sender, global::Tizen.Applications.Messages.MessageReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } /// @@ -2632,9 +2340,7 @@ namespace Tizen.Applications.Messages { void Handler(object sender, global::Tizen.Applications.Messages.RemotePortStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemotePortStateChanged += x, x => _data.RemotePortStateChanged -= x); + }, x => _data.RemotePortStateChanged += x, x => _data.RemotePortStateChanged -= x); } } @@ -2673,9 +2379,7 @@ namespace Tizen.Content.Download { void Handler(object sender, global::Tizen.Content.Download.ProgressChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2683,9 +2387,7 @@ namespace Tizen.Content.Download { void Handler(object sender, global::Tizen.Content.Download.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -2728,9 +2430,7 @@ namespace Tizen.Location { void Handler(object sender, global::Tizen.Location.SatelliteStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SatelliteStatusUpdated += x, x => _data.SatelliteStatusUpdated -= x); + }, x => _data.SatelliteStatusUpdated += x, x => _data.SatelliteStatusUpdated -= x); } /// @@ -2755,9 +2455,7 @@ namespace Tizen.Location { void Handler(object sender, global::Tizen.Location.LocationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DistanceBasedLocationChanged += x, x => _data.DistanceBasedLocationChanged -= x); + }, x => _data.DistanceBasedLocationChanged += x, x => _data.DistanceBasedLocationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2765,9 +2463,7 @@ namespace Tizen.Location { void Handler(object sender, global::Tizen.Location.LocationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2775,9 +2471,7 @@ namespace Tizen.Location { void Handler(object sender, global::Tizen.Location.ServiceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServiceStateChanged += x, x => _data.ServiceStateChanged -= x); + }, x => _data.ServiceStateChanged += x, x => _data.ServiceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2785,9 +2479,7 @@ namespace Tizen.Location { void Handler(object sender, global::Tizen.Location.SettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SettingChanged += x, x => _data.SettingChanged -= x); + }, x => _data.SettingChanged += x, x => _data.SettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2795,9 +2487,7 @@ namespace Tizen.Location { void Handler(object sender, global::Tizen.Location.ZoneChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ZoneChanged += x, x => _data.ZoneChanged -= x); + }, x => _data.ZoneChanged += x, x => _data.ZoneChanged -= x); } } @@ -2836,9 +2526,7 @@ namespace Tizen.Location.Geofence { void Handler(object sender, global::Tizen.Location.Geofence.GeofenceResponseEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GeofenceEventChanged += x, x => _data.GeofenceEventChanged -= x); + }, x => _data.GeofenceEventChanged += x, x => _data.GeofenceEventChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2846,9 +2534,7 @@ namespace Tizen.Location.Geofence { void Handler(object sender, global::Tizen.Location.Geofence.ProximityStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ProximityChanged += x, x => _data.ProximityChanged -= x); + }, x => _data.ProximityChanged += x, x => _data.ProximityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2856,9 +2542,7 @@ namespace Tizen.Location.Geofence { void Handler(object sender, global::Tizen.Location.Geofence.GeofenceStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -2909,9 +2593,7 @@ namespace Tizen.Maps { void Handler(object sender, global::Tizen.Maps.MapGestureEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2919,9 +2601,7 @@ namespace Tizen.Maps { void Handler(object sender, global::Tizen.Maps.MapGestureEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DoubleClicked += x, x => _data.DoubleClicked -= x); + }, x => _data.DoubleClicked += x, x => _data.DoubleClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2929,9 +2609,7 @@ namespace Tizen.Maps { void Handler(object sender, global::Tizen.Maps.MapGestureEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LongPressed += x, x => _data.LongPressed -= x); + }, x => _data.LongPressed += x, x => _data.LongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2939,9 +2617,7 @@ namespace Tizen.Maps { void Handler(object sender, global::Tizen.Maps.MapGestureEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2949,9 +2625,7 @@ namespace Tizen.Maps { void Handler(object sender, global::Tizen.Maps.MapGestureEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TwoFingerClicked += x, x => _data.TwoFingerClicked -= x); + }, x => _data.TwoFingerClicked += x, x => _data.TwoFingerClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2959,9 +2633,7 @@ namespace Tizen.Maps { void Handler(object sender, global::Tizen.Maps.MapGestureEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TwoFingerRotated += x, x => _data.TwoFingerRotated -= x); + }, x => _data.TwoFingerRotated += x, x => _data.TwoFingerRotated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2969,9 +2641,7 @@ namespace Tizen.Maps { void Handler(object sender, global::Tizen.Maps.MapGestureEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TwoFingerZoomed += x, x => _data.TwoFingerZoomed -= x); + }, x => _data.TwoFingerZoomed += x, x => _data.TwoFingerZoomed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2979,9 +2649,7 @@ namespace Tizen.Maps { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewReady += x, x => _data.ViewReady -= x); + }, x => _data.ViewReady += x, x => _data.ViewReady -= x); } /// @@ -3006,9 +2674,7 @@ namespace Tizen.Maps { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -3033,9 +2699,7 @@ namespace Tizen.Maps { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -3060,9 +2724,7 @@ namespace Tizen.Maps { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } } @@ -3141,9 +2803,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioDataAvailableEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataAvailable += x, x => _data.DataAvailable -= x); + }, x => _data.DataAvailable += x, x => _data.DataAvailable -= x); } /// @@ -3168,9 +2828,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioIOStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -3195,9 +2853,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioPlaybackBufferAvailableEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferAvailable += x, x => _data.BufferAvailable -= x); + }, x => _data.BufferAvailable += x, x => _data.BufferAvailable -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3205,9 +2861,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioIOStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -3232,9 +2886,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioStreamPolicyFocusStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusStateChanged += x, x => _data.FocusStateChanged -= x); + }, x => _data.FocusStateChanged += x, x => _data.FocusStateChanged -= x); } /// @@ -3259,9 +2911,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.VolumeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } /// @@ -3286,9 +2936,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CaptureCompleted += x, x => _data.CaptureCompleted -= x); + }, x => _data.CaptureCompleted += x, x => _data.CaptureCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3296,9 +2944,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.CameraCapturingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Capturing += x, x => _data.Capturing -= x); + }, x => _data.Capturing += x, x => _data.Capturing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3306,9 +2952,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.CameraErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3316,9 +2960,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.FaceDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FaceDetected += x, x => _data.FaceDetected -= x); + }, x => _data.FaceDetected += x, x => _data.FaceDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3326,9 +2968,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.CameraFocusStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusStateChanged += x, x => _data.FocusStateChanged -= x); + }, x => _data.FocusStateChanged += x, x => _data.FocusStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3336,9 +2976,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.HdrCaptureProgressEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.HdrCaptureProgress += x, x => _data.HdrCaptureProgress -= x); + }, x => _data.HdrCaptureProgress += x, x => _data.HdrCaptureProgress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3346,9 +2984,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.CameraInterruptedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Interrupted += x, x => _data.Interrupted -= x); + }, x => _data.Interrupted += x, x => _data.Interrupted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3356,9 +2992,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.CameraInterruptStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InterruptStarted += x, x => _data.InterruptStarted -= x); + }, x => _data.InterruptStarted += x, x => _data.InterruptStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3366,9 +3000,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.MediaPacketPreviewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaPacketPreview += x, x => _data.MediaPacketPreview -= x); + }, x => _data.MediaPacketPreview += x, x => _data.MediaPacketPreview -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3376,9 +3008,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.PreviewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Preview += x, x => _data.Preview -= x); + }, x => _data.Preview += x, x => _data.Preview -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3386,9 +3016,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.CameraStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -3413,9 +3041,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.MediaStreamBufferStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferStatusChanged += x, x => _data.BufferStatusChanged -= x); + }, x => _data.BufferStatusChanged += x, x => _data.BufferStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3423,9 +3049,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.MediaStreamSeekingOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SeekingOccurred += x, x => _data.SeekingOccurred -= x); + }, x => _data.SeekingOccurred += x, x => _data.SeekingOccurred -= x); } /// @@ -3450,9 +3074,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.BufferingProgressChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3460,9 +3082,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.PlayerErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3470,9 +3090,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); + }, x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3480,9 +3098,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.PlaybackInterruptedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackInterrupted += x, x => _data.PlaybackInterrupted -= x); + }, x => _data.PlaybackInterrupted += x, x => _data.PlaybackInterrupted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3490,9 +3106,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.SubtitleUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SubtitleUpdated += x, x => _data.SubtitleUpdated -= x); + }, x => _data.SubtitleUpdated += x, x => _data.SubtitleUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3500,9 +3114,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.VideoFrameDecodedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VideoFrameDecoded += x, x => _data.VideoFrameDecoded -= x); + }, x => _data.VideoFrameDecoded += x, x => _data.VideoFrameDecoded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3510,9 +3122,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.VideoStreamChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VideoStreamChanged += x, x => _data.VideoStreamChanged -= x); + }, x => _data.VideoStreamChanged += x, x => _data.VideoStreamChanged -= x); } /// @@ -3537,9 +3147,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RadioInterruptedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Interrupted += x, x => _data.Interrupted -= x); + }, x => _data.Interrupted += x, x => _data.Interrupted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3547,9 +3155,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScanCompleted += x, x => _data.ScanCompleted -= x); + }, x => _data.ScanCompleted += x, x => _data.ScanCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3557,9 +3163,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScanStopped += x, x => _data.ScanStopped -= x); + }, x => _data.ScanStopped += x, x => _data.ScanStopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3567,9 +3171,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.ScanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScanUpdated += x, x => _data.ScanUpdated -= x); + }, x => _data.ScanUpdated += x, x => _data.ScanUpdated -= x); } /// @@ -3594,9 +3196,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioStreamStoringEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AudioStreamStoring += x, x => _data.AudioStreamStoring -= x); + }, x => _data.AudioStreamStoring += x, x => _data.AudioStreamStoring -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3604,9 +3204,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecordingErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3614,9 +3212,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecorderInterruptedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Interrupted += x, x => _data.Interrupted -= x); + }, x => _data.Interrupted += x, x => _data.Interrupted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3624,9 +3220,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecorderInterruptingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Interrupting += x, x => _data.Interrupting -= x); + }, x => _data.Interrupting += x, x => _data.Interrupting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3634,9 +3228,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.MuxedStreamDeliveredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MuxedStreamDelivered += x, x => _data.MuxedStreamDelivered -= x); + }, x => _data.MuxedStreamDelivered += x, x => _data.MuxedStreamDelivered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3644,9 +3236,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecordingLimitReachedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RecordingLimitReached += x, x => _data.RecordingLimitReached -= x); + }, x => _data.RecordingLimitReached += x, x => _data.RecordingLimitReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3654,9 +3244,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecordingStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RecordingStatusChanged += x, x => _data.RecordingStatusChanged -= x); + }, x => _data.RecordingStatusChanged += x, x => _data.RecordingStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3664,9 +3252,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecorderStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -3691,9 +3277,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.StreamRecorderBufferConsumedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferConsumed += x, x => _data.BufferConsumed -= x); + }, x => _data.BufferConsumed += x, x => _data.BufferConsumed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3701,9 +3285,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.StreamRecorderErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3711,9 +3293,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecordingLimitReachedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RecordingLimitReached += x, x => _data.RecordingLimitReached -= x); + }, x => _data.RecordingLimitReached += x, x => _data.RecordingLimitReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3721,9 +3301,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecordingStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RecordingStatusChanged += x, x => _data.RecordingStatusChanged -= x); + }, x => _data.RecordingStatusChanged += x, x => _data.RecordingStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3731,9 +3309,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.StreamRecorderStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -3772,9 +3348,7 @@ namespace Tizen.Multimedia.MediaCodec { void Handler(object sender, global::Tizen.Multimedia.MediaCodec.BufferStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferStatusChanged += x, x => _data.BufferStatusChanged -= x); + }, x => _data.BufferStatusChanged += x, x => _data.BufferStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3782,9 +3356,7 @@ namespace Tizen.Multimedia.MediaCodec { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EosReached += x, x => _data.EosReached -= x); + }, x => _data.EosReached += x, x => _data.EosReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3792,9 +3364,7 @@ namespace Tizen.Multimedia.MediaCodec { void Handler(object sender, global::Tizen.Multimedia.MediaCodec.MediaCodecErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3802,9 +3372,7 @@ namespace Tizen.Multimedia.MediaCodec { void Handler(object sender, global::Tizen.Multimedia.MediaCodec.InputProcessedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InputProcessed += x, x => _data.InputProcessed -= x); + }, x => _data.InputProcessed += x, x => _data.InputProcessed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3812,9 +3380,7 @@ namespace Tizen.Multimedia.MediaCodec { void Handler(object sender, global::Tizen.Multimedia.MediaCodec.OutputAvailableEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OutputAvailable += x, x => _data.OutputAvailable -= x); + }, x => _data.OutputAvailable += x, x => _data.OutputAvailable -= x); } } @@ -3861,9 +3427,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.MetadataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MetadataUpdated += x, x => _data.MetadataUpdated -= x); + }, x => _data.MetadataUpdated += x, x => _data.MetadataUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3871,9 +3435,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.PlaybackStateUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStateUpdated += x, x => _data.PlaybackStateUpdated -= x); + }, x => _data.PlaybackStateUpdated += x, x => _data.PlaybackStateUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3881,9 +3443,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.RepeatModeUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RepeatModeUpdated += x, x => _data.RepeatModeUpdated -= x); + }, x => _data.RepeatModeUpdated += x, x => _data.RepeatModeUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3891,9 +3451,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServerStopped += x, x => _data.ServerStopped -= x); + }, x => _data.ServerStopped += x, x => _data.ServerStopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3901,9 +3459,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.ShuffleModeUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ShuffleModeUpdated += x, x => _data.ShuffleModeUpdated -= x); + }, x => _data.ShuffleModeUpdated += x, x => _data.ShuffleModeUpdated -= x); } /// @@ -3928,9 +3484,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.MediaControlServerStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServerStarted += x, x => _data.ServerStarted -= x); + }, x => _data.ServerStarted += x, x => _data.ServerStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3938,9 +3492,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.MediaControlServerStoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServerStopped += x, x => _data.ServerStopped -= x); + }, x => _data.ServerStopped += x, x => _data.ServerStopped -= x); } /// @@ -3965,9 +3517,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.ScreenMirroringErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3975,9 +3525,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.ScreenMirroringStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -4024,9 +3572,7 @@ namespace Tizen.Multimedia.Vision { void Handler(object sender, global::Tizen.Multimedia.Vision.MovementDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Detected += x, x => _data.Detected -= x); + }, x => _data.Detected += x, x => _data.Detected -= x); } /// @@ -4051,9 +3597,7 @@ namespace Tizen.Multimedia.Vision { void Handler(object sender, global::Tizen.Multimedia.Vision.PersonAppearanceDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Detected += x, x => _data.Detected -= x); + }, x => _data.Detected += x, x => _data.Detected -= x); } /// @@ -4078,9 +3622,7 @@ namespace Tizen.Multimedia.Vision { void Handler(object sender, global::Tizen.Multimedia.Vision.PersonRecognizedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Recognized += x, x => _data.Recognized -= x); + }, x => _data.Recognized += x, x => _data.Recognized -= x); } } @@ -4167,9 +3709,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.AudioConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AudioConnectionStateChanged += x, x => _data.AudioConnectionStateChanged -= x); + }, x => _data.AudioConnectionStateChanged += x, x => _data.AudioConnectionStateChanged -= x); } /// @@ -4194,9 +3734,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.EqualizerStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EqualizerStateChanged += x, x => _data.EqualizerStateChanged -= x); + }, x => _data.EqualizerStateChanged += x, x => _data.EqualizerStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4204,9 +3742,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.RepeatModeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RepeatModeChanged += x, x => _data.RepeatModeChanged -= x); + }, x => _data.RepeatModeChanged += x, x => _data.RepeatModeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4214,9 +3750,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.ScanModeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScanModeChanged += x, x => _data.ScanModeChanged -= x); + }, x => _data.ScanModeChanged += x, x => _data.ScanModeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4224,9 +3758,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.ShuffleModeChangedeventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ShuffleModeChanged += x, x => _data.ShuffleModeChanged -= x); + }, x => _data.ShuffleModeChanged += x, x => _data.ShuffleModeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4234,9 +3766,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.TargetConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TargetConnectionStateChanged += x, x => _data.TargetConnectionStateChanged -= x); + }, x => _data.TargetConnectionStateChanged += x, x => _data.TargetConnectionStateChanged -= x); } /// @@ -4261,9 +3791,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.AuthorizationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AuthorizationChanged += x, x => _data.AuthorizationChanged -= x); + }, x => _data.AuthorizationChanged += x, x => _data.AuthorizationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4271,9 +3799,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.BondCreatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BondCreated += x, x => _data.BondCreated -= x); + }, x => _data.BondCreated += x, x => _data.BondCreated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4281,9 +3807,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.BondDestroyedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BondDestroyed += x, x => _data.BondDestroyed -= x); + }, x => _data.BondDestroyed += x, x => _data.BondDestroyed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4291,9 +3815,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.DeviceConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConnectionStateChanged += x, x => _data.ConnectionStateChanged -= x); + }, x => _data.ConnectionStateChanged += x, x => _data.ConnectionStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4301,9 +3823,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.ServiceSearchedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServiceSearched += x, x => _data.ServiceSearched -= x); + }, x => _data.ServiceSearched += x, x => _data.ServiceSearched -= x); } /// @@ -4328,9 +3848,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.ReadRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4338,9 +3856,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.WriteRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); } /// @@ -4365,9 +3881,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.NotificationStateChangedEventArg e) => eventHandler(e); return Handler; - } - - , x => _data.NotificationStateChanged += x, x => _data.NotificationStateChanged -= x); + }, x => _data.NotificationStateChanged += x, x => _data.NotificationStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4375,9 +3889,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -4402,9 +3914,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.NotificationSentEventArg e) => eventHandler(e); return Handler; - } - - , x => _data.NotificationSent += x, x => _data.NotificationSent -= x); + }, x => _data.NotificationSent += x, x => _data.NotificationSent -= x); } /// @@ -4429,9 +3939,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.HidConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.HidConnectionStateChanged += x, x => _data.HidConnectionStateChanged -= x); + }, x => _data.HidConnectionStateChanged += x, x => _data.HidConnectionStateChanged -= x); } /// @@ -4456,9 +3964,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.AdvertisingStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AdvertisingStateChanged += x, x => _data.AdvertisingStateChanged -= x); + }, x => _data.AdvertisingStateChanged += x, x => _data.AdvertisingStateChanged -= x); } /// @@ -4483,9 +3989,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.GattConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GattConnectionStateChanged += x, x => _data.GattConnectionStateChanged -= x); + }, x => _data.GattConnectionStateChanged += x, x => _data.GattConnectionStateChanged -= x); } /// @@ -4510,9 +4014,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.PushFinishedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushFinished += x, x => _data.PushFinished -= x); + }, x => _data.PushFinished += x, x => _data.PushFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4520,9 +4022,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.PushProgressEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushProgress += x, x => _data.PushProgress -= x); + }, x => _data.PushProgress += x, x => _data.PushProgress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4530,9 +4030,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.PushRespondedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushResponded += x, x => _data.PushResponded -= x); + }, x => _data.PushResponded += x, x => _data.PushResponded -= x); } /// @@ -4557,9 +4055,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.ConnectionRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); + }, x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4567,9 +4063,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.TransferFinishedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TransferFinished += x, x => _data.TransferFinished -= x); + }, x => _data.TransferFinished += x, x => _data.TransferFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4577,9 +4071,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.TransferProgressEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TransferProgress += x, x => _data.TransferProgress -= x); + }, x => _data.TransferProgress += x, x => _data.TransferProgress -= x); } /// @@ -4604,9 +4096,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.AcceptStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AcceptStateChanged += x, x => _data.AcceptStateChanged -= x); + }, x => _data.AcceptStateChanged += x, x => _data.AcceptStateChanged -= x); } /// @@ -4631,9 +4121,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.SocketConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConnectionStateChanged += x, x => _data.ConnectionStateChanged -= x); + }, x => _data.ConnectionStateChanged += x, x => _data.ConnectionStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4641,9 +4129,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.SocketDataReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); } } @@ -4682,9 +4168,7 @@ namespace Tizen.Network.Connection { void Handler(object sender, global::Tizen.Network.Connection.ProfileStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ProfileStateChanged += x, x => _data.ProfileStateChanged -= x); + }, x => _data.ProfileStateChanged += x, x => _data.ProfileStateChanged -= x); } } @@ -4723,9 +4207,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.CacheUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CacheUpdated += x, x => _data.CacheUpdated -= x); + }, x => _data.CacheUpdated += x, x => _data.CacheUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4733,9 +4215,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.ObserverNotifiedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ObserverNotified += x, x => _data.ObserverNotified -= x); + }, x => _data.ObserverNotified += x, x => _data.ObserverNotified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4743,9 +4223,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -4796,9 +4274,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.SecureElementTranscationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EseSecureElementTransactionEvent += x, x => _data.EseSecureElementTransactionEvent -= x); + }, x => _data.EseSecureElementTransactionEvent += x, x => _data.EseSecureElementTransactionEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4806,9 +4282,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.HostCardEmulationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.HostCardEmulationEvent += x, x => _data.HostCardEmulationEvent -= x); + }, x => _data.HostCardEmulationEvent += x, x => _data.HostCardEmulationEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4816,9 +4290,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.SecureElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SecureElementEvent += x, x => _data.SecureElementEvent -= x); + }, x => _data.SecureElementEvent += x, x => _data.SecureElementEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4826,9 +4298,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.SecureElementTranscationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UiccSecureElementTransactionEvent += x, x => _data.UiccSecureElementTransactionEvent -= x); + }, x => _data.UiccSecureElementTransactionEvent += x, x => _data.UiccSecureElementTransactionEvent -= x); } /// @@ -4853,9 +4323,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.P2pDataReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.P2pDataReceived += x, x => _data.P2pDataReceived -= x); + }, x => _data.P2pDataReceived += x, x => _data.P2pDataReceived -= x); } /// @@ -4880,9 +4348,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.P2pTargetDiscoveredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.P2pTargetDiscovered += x, x => _data.P2pTargetDiscovered -= x); + }, x => _data.P2pTargetDiscovered += x, x => _data.P2pTargetDiscovered -= x); } /// @@ -4907,9 +4373,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.TagDiscoveredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TagDiscovered += x, x => _data.TagDiscovered -= x); + }, x => _data.TagDiscovered += x, x => _data.TagDiscovered -= x); } } @@ -4952,9 +4416,7 @@ namespace Tizen.Network.Nsd { void Handler(object sender, global::Tizen.Network.Nsd.DnssdServiceFoundEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServiceFound += x, x => _data.ServiceFound -= x); + }, x => _data.ServiceFound += x, x => _data.ServiceFound -= x); } /// @@ -4979,9 +4441,7 @@ namespace Tizen.Network.Nsd { void Handler(object sender, global::Tizen.Network.Nsd.SsdpServiceFoundEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServiceFound += x, x => _data.ServiceFound -= x); + }, x => _data.ServiceFound += x, x => _data.ServiceFound -= x); } } @@ -5020,9 +4480,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.ConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConnectionStateChanged += x, x => _data.ConnectionStateChanged -= x); + }, x => _data.ConnectionStateChanged += x, x => _data.ConnectionStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5030,9 +4488,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.IpAddressAssignedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IpAddressAssigned += x, x => _data.IpAddressAssigned -= x); + }, x => _data.IpAddressAssigned += x, x => _data.IpAddressAssigned -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5040,9 +4496,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.ServiceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServiceStateChanged += x, x => _data.ServiceStateChanged -= x); + }, x => _data.ServiceStateChanged += x, x => _data.ServiceStateChanged -= x); } } @@ -5117,9 +4571,7 @@ namespace Tizen.NUI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Finished += x, x => _data.Finished -= x); + }, x => _data.Finished += x, x => _data.Finished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5127,9 +4579,7 @@ namespace Tizen.NUI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ProgressReached += x, x => _data.ProgressReached -= x); + }, x => _data.ProgressReached += x, x => _data.ProgressReached -= x); } /// @@ -5154,9 +4604,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.FocusManager.FocusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChanged += x, x => _data.FocusChanged -= x); + }, x => _data.FocusChanged += x, x => _data.FocusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5164,9 +4612,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.FocusManager.FocusedViewActivatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusedViewActivated += x, x => _data.FocusedViewActivated -= x); + }, x => _data.FocusedViewActivated += x, x => _data.FocusedViewActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5175,9 +4621,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.FocusManager.FocusedViewEnterKeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusedViewEnterKeyPressed += x, x => _data.FocusedViewEnterKeyPressed -= x); + }, x => _data.FocusedViewEnterKeyPressed += x, x => _data.FocusedViewEnterKeyPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5185,9 +4629,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.FocusManager.FocusGroupChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusGroupChanged += x, x => _data.FocusGroupChanged -= x); + }, x => _data.FocusGroupChanged += x, x => _data.FocusGroupChanged -= x); } /// @@ -5212,9 +4654,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.ImfManager.ActivatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5222,9 +4662,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.ImfManager.KeyboardTypeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyboardTypeChanged += x, x => _data.KeyboardTypeChanged -= x); + }, x => _data.KeyboardTypeChanged += x, x => _data.KeyboardTypeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5232,9 +4670,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.ImfManager.LanguageChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); + }, x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5242,9 +4678,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.ImfManager.ResizedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resized += x, x => _data.Resized -= x); + }, x => _data.Resized += x, x => _data.Resized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5252,9 +4686,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.ImfManager.StatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -5279,9 +4711,7 @@ namespace Tizen.NUI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paused += x, x => _data.Paused -= x); + }, x => _data.Paused += x, x => _data.Paused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5289,9 +4719,7 @@ namespace Tizen.NUI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resumed += x, x => _data.Resumed -= x); + }, x => _data.Resumed += x, x => _data.Resumed -= x); } /// @@ -5316,9 +4744,7 @@ namespace Tizen.NUI { void Handler(object source, global::Tizen.NUI.PropertyNotification.NotifyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Notified += x, x => _data.Notified -= x); + }, x => _data.Notified += x, x => _data.Notified -= x); } /// @@ -5343,9 +4769,7 @@ namespace Tizen.NUI { void Handler(object source, global::Tizen.NUI.ScrollView.SnapStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SnapStarted += x, x => _data.SnapStarted -= x); + }, x => _data.SnapStarted += x, x => _data.SnapStarted -= x); } /// @@ -5370,9 +4794,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.StyleManager.StyleChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); } /// @@ -5397,9 +4819,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.TTSPlayer.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -5424,9 +4844,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.WidgetView.WidgetViewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WidgetAdded += x, x => _data.WidgetAdded -= x); + }, x => _data.WidgetAdded += x, x => _data.WidgetAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5434,9 +4852,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.WidgetView.WidgetViewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WidgetContentUpdated += x, x => _data.WidgetContentUpdated -= x); + }, x => _data.WidgetContentUpdated += x, x => _data.WidgetContentUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5444,9 +4860,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.WidgetView.WidgetViewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WidgetCreationAborted += x, x => _data.WidgetCreationAborted -= x); + }, x => _data.WidgetCreationAborted += x, x => _data.WidgetCreationAborted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5454,9 +4868,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.WidgetView.WidgetViewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WidgetDeleted += x, x => _data.WidgetDeleted -= x); + }, x => _data.WidgetDeleted += x, x => _data.WidgetDeleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5464,9 +4876,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.WidgetView.WidgetViewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WidgetFaulted += x, x => _data.WidgetFaulted -= x); + }, x => _data.WidgetFaulted += x, x => _data.WidgetFaulted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5474,9 +4884,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.WidgetView.WidgetViewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WidgetUpdatePeriodChanged += x, x => _data.WidgetUpdatePeriodChanged -= x); + }, x => _data.WidgetUpdatePeriodChanged += x, x => _data.WidgetUpdatePeriodChanged -= x); } /// @@ -5501,9 +4909,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.Window.FocusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChanged += x, x => _data.FocusChanged -= x); + }, x => _data.FocusChanged += x, x => _data.FocusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5511,9 +4917,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.Window.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyEvent += x, x => _data.KeyEvent -= x); + }, x => _data.KeyEvent += x, x => _data.KeyEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5521,9 +4925,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.Window.ResizedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resized += x, x => _data.Resized -= x); + }, x => _data.Resized += x, x => _data.Resized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5531,9 +4933,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.Window.TouchEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); + }, x => _data.TouchEvent += x, x => _data.TouchEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5541,9 +4941,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.Window.WheelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WheelEvent += x, x => _data.WheelEvent -= x); + }, x => _data.WheelEvent += x, x => _data.WheelEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5552,9 +4950,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.Window.WindowFocusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WindowFocusChanged += x, x => _data.WindowFocusChanged -= x); + }, x => _data.WindowFocusChanged += x, x => _data.WindowFocusChanged -= x); } } @@ -5613,9 +5009,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.ImageView.ResourceReadyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourceReady += x, x => _data.ResourceReady -= x); + }, x => _data.ResourceReady += x, x => _data.ResourceReady -= x); } /// @@ -5640,9 +5034,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object source, global::Tizen.NUI.BaseComponents.Scrollable.CompletedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollCompleted += x, x => _data.ScrollCompleted -= x); + }, x => _data.ScrollCompleted += x, x => _data.ScrollCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5650,9 +5042,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object source, global::Tizen.NUI.BaseComponents.Scrollable.StartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollStarted += x, x => _data.ScrollStarted -= x); + }, x => _data.ScrollStarted += x, x => _data.ScrollStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5660,9 +5050,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object source, global::Tizen.NUI.BaseComponents.Scrollable.UpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollUpdated += x, x => _data.ScrollUpdated -= x); + }, x => _data.ScrollUpdated += x, x => _data.ScrollUpdated -= x); } /// @@ -5687,9 +5075,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.TextEditor.ScrollStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollStateChanged += x, x => _data.ScrollStateChanged -= x); + }, x => _data.ScrollStateChanged += x, x => _data.ScrollStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5697,9 +5083,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.TextEditor.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -5724,9 +5108,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.TextField.MaxLengthReachedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MaxLengthReached += x, x => _data.MaxLengthReached -= x); + }, x => _data.MaxLengthReached += x, x => _data.MaxLengthReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5734,9 +5116,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.TextField.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -5761,9 +5141,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.VideoView.FinishedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Finished += x, x => _data.Finished -= x); + }, x => _data.Finished += x, x => _data.Finished -= x); } /// @@ -5788,9 +5166,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AddedToWindow += x, x => _data.AddedToWindow -= x); + }, x => _data.AddedToWindow += x, x => _data.AddedToWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5798,9 +5174,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusGained += x, x => _data.FocusGained -= x); + }, x => _data.FocusGained += x, x => _data.FocusGained -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5808,9 +5182,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusLost += x, x => _data.FocusLost -= x); + }, x => _data.FocusLost += x, x => _data.FocusLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5818,9 +5190,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.View.LayoutDirectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutDirectionChanged += x, x => _data.LayoutDirectionChanged -= x); + }, x => _data.LayoutDirectionChanged += x, x => _data.LayoutDirectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5828,9 +5198,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Relayout += x, x => _data.Relayout -= x); + }, x => _data.Relayout += x, x => _data.Relayout -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5838,9 +5206,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovedFromWindow += x, x => _data.RemovedFromWindow -= x); + }, x => _data.RemovedFromWindow += x, x => _data.RemovedFromWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5848,9 +5214,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesLoaded += x, x => _data.ResourcesLoaded -= x); + }, x => _data.ResourcesLoaded += x, x => _data.ResourcesLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5858,9 +5222,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.View.VisibilityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } } @@ -5907,9 +5269,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.Popup.HiddenEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Hidden += x, x => _data.Hidden -= x); + }, x => _data.Hidden += x, x => _data.Hidden -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5917,9 +5277,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.Popup.HidingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Hiding += x, x => _data.Hiding -= x); + }, x => _data.Hiding += x, x => _data.Hiding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5927,9 +5285,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.Popup.ShowingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Showing += x, x => _data.Showing -= x); + }, x => _data.Showing += x, x => _data.Showing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5937,9 +5293,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.Popup.ShownEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Shown += x, x => _data.Shown -= x); + }, x => _data.Shown += x, x => _data.Shown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5947,9 +5301,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.Popup.TouchedOutsideEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TouchedOutside += x, x => _data.TouchedOutside -= x); + }, x => _data.TouchedOutside += x, x => _data.TouchedOutside -= x); } /// @@ -5974,9 +5326,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.ProgressBar.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -6001,9 +5351,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.ScrollBar.PanFinishedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanFinished += x, x => _data.PanFinished -= x); + }, x => _data.PanFinished += x, x => _data.PanFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6011,9 +5359,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.ScrollBar.ScrollIntervalEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollInterval += x, x => _data.ScrollInterval -= x); + }, x => _data.ScrollInterval += x, x => _data.ScrollInterval -= x); } } @@ -6056,9 +5402,7 @@ namespace Tizen.Pims.Contacts { void Handler(object sender, global::Tizen.Pims.Contacts.DBStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DBStatusChanged += x, x => _data.DBStatusChanged -= x); + }, x => _data.DBStatusChanged += x, x => _data.DBStatusChanged -= x); } /// @@ -6083,9 +5427,7 @@ namespace Tizen.Pims.Contacts { void Handler(object sender, global::Tizen.Pims.Contacts.NameDisplayOrderChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NameDisplayOrderChanged += x, x => _data.NameDisplayOrderChanged -= x); + }, x => _data.NameDisplayOrderChanged += x, x => _data.NameDisplayOrderChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6093,9 +5435,7 @@ namespace Tizen.Pims.Contacts { void Handler(object sender, global::Tizen.Pims.Contacts.NameSortingOrderChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NameSortingOrderChanged += x, x => _data.NameSortingOrderChanged -= x); + }, x => _data.NameSortingOrderChanged += x, x => _data.NameSortingOrderChanged -= x); } } @@ -6134,9 +5474,7 @@ namespace Tizen.Security { void Handler(object sender, global::Tizen.Security.RequestResponseEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResponseFetched += x, x => _data.ResponseFetched -= x); + }, x => _data.ResponseFetched += x, x => _data.ResponseFetched -= x); } } @@ -6279,9 +5617,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.AccelerometerDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6306,9 +5642,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.FaceDownGestureDetectorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6333,9 +5667,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SensorAccuracyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); + }, x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6343,9 +5675,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.GravitySensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6370,9 +5700,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.GyroscopeDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6397,9 +5725,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.GyroscopeRotationVectorSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6424,9 +5750,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.HeartRateMonitorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6451,9 +5775,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.HumiditySensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6478,9 +5800,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.InVehicleActivityDetectorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6505,9 +5825,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.LightSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6532,9 +5850,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SensorAccuracyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); + }, x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6542,9 +5858,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.LinearAccelerationSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6569,9 +5883,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SensorAccuracyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); + }, x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6579,9 +5891,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.MagnetometerDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6606,9 +5916,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SensorAccuracyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); + }, x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6616,9 +5924,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.MagnetometerRotationVectorSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6643,9 +5949,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SensorAccuracyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); + }, x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6653,9 +5957,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.OrientationSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6680,9 +5982,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.PedometerDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6707,9 +6007,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.PickUpGestureDetectorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6734,9 +6032,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.PressureSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6761,9 +6057,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.ProximitySensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6788,9 +6082,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SensorAccuracyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); + }, x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6798,9 +6090,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.RotationVectorSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6825,9 +6115,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.RunningActivityDetectorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6852,9 +6140,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SleepMonitorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6879,9 +6165,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.StationaryActivityDetectorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6906,9 +6190,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.TemperatureSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6933,9 +6215,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.UltravioletSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6960,9 +6240,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.UncalibratedGyroscopeDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6987,9 +6265,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SensorAccuracyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); + }, x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6997,9 +6273,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.UncalibratedMagnetometerDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -7024,9 +6298,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.WalkingActivityDetectorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -7051,9 +6323,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.WristUpGestureDetectorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } } @@ -7092,9 +6362,7 @@ namespace Tizen.System { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StorageStateChanged += x, x => _data.StorageStateChanged -= x); + }, x => _data.StorageStateChanged += x, x => _data.StorageStateChanged -= x); } } @@ -7133,9 +6401,7 @@ namespace Tizen.System.Usb { void Handler(object sender, global::Tizen.System.Usb.HotPluggedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DeviceHotPlugged += x, x => _data.DeviceHotPlugged -= x); + }, x => _data.DeviceHotPlugged += x, x => _data.DeviceHotPlugged -= x); } } @@ -7174,9 +6440,7 @@ namespace Tizen.Telephony { void Handler(object sender, global::Tizen.Telephony.ChangeNotificationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChangeNotification += x, x => _data.ChangeNotification -= x); + }, x => _data.ChangeNotification += x, x => _data.ChangeNotification -= x); } } @@ -7215,9 +6479,7 @@ namespace Tizen.Uix.Stt { void Handler(object sender, global::Tizen.Uix.Stt.DefaultLanguageChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DefaultLanguageChanged += x, x => _data.DefaultLanguageChanged -= x); + }, x => _data.DefaultLanguageChanged += x, x => _data.DefaultLanguageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7225,9 +6487,7 @@ namespace Tizen.Uix.Stt { void Handler(object sender, global::Tizen.Uix.Stt.EngineChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EngineChanged += x, x => _data.EngineChanged -= x); + }, x => _data.EngineChanged += x, x => _data.EngineChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7235,9 +6495,7 @@ namespace Tizen.Uix.Stt { void Handler(object sender, global::Tizen.Uix.Stt.ErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7245,9 +6503,7 @@ namespace Tizen.Uix.Stt { void Handler(object sender, global::Tizen.Uix.Stt.RecognitionResultEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RecognitionResult += x, x => _data.RecognitionResult -= x); + }, x => _data.RecognitionResult += x, x => _data.RecognitionResult -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7255,9 +6511,7 @@ namespace Tizen.Uix.Stt { void Handler(object sender, global::Tizen.Uix.Stt.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -7296,9 +6550,7 @@ namespace Tizen.Uix.Tts { void Handler(object sender, global::Tizen.Uix.Tts.DefaultVoiceChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DefaultVoiceChanged += x, x => _data.DefaultVoiceChanged -= x); + }, x => _data.DefaultVoiceChanged += x, x => _data.DefaultVoiceChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7306,9 +6558,7 @@ namespace Tizen.Uix.Tts { void Handler(object sender, global::Tizen.Uix.Tts.EngineChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EngineChanged += x, x => _data.EngineChanged -= x); + }, x => _data.EngineChanged += x, x => _data.EngineChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7316,9 +6566,7 @@ namespace Tizen.Uix.Tts { void Handler(object sender, global::Tizen.Uix.Tts.ErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7326,9 +6574,7 @@ namespace Tizen.Uix.Tts { void Handler(object sender, global::Tizen.Uix.Tts.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7336,9 +6582,7 @@ namespace Tizen.Uix.Tts { void Handler(object sender, global::Tizen.Uix.Tts.UtteranceEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UtteranceCompleted += x, x => _data.UtteranceCompleted -= x); + }, x => _data.UtteranceCompleted += x, x => _data.UtteranceCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7346,9 +6590,7 @@ namespace Tizen.Uix.Tts { void Handler(object sender, global::Tizen.Uix.Tts.UtteranceEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UtteranceStarted += x, x => _data.UtteranceStarted -= x); + }, x => _data.UtteranceStarted += x, x => _data.UtteranceStarted -= x); } } @@ -7387,9 +6629,7 @@ namespace Tizen.WebView { void Handler(object sender, global::Tizen.WebView.SmartCallbackLoadErrorArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadError += x, x => _data.LoadError -= x); + }, x => _data.LoadError += x, x => _data.LoadError -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7397,9 +6637,7 @@ namespace Tizen.WebView { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadFinished += x, x => _data.LoadFinished -= x); + }, x => _data.LoadFinished += x, x => _data.LoadFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7407,9 +6645,7 @@ namespace Tizen.WebView { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadStarted += x, x => _data.LoadStarted -= x); + }, x => _data.LoadStarted += x, x => _data.LoadStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7417,9 +6653,7 @@ namespace Tizen.WebView { void Handler(object sender, global::Tizen.WebView.SmartCallbackArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TitleChanged += x, x => _data.TitleChanged -= x); + }, x => _data.TitleChanged += x, x => _data.TitleChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7427,9 +6661,7 @@ namespace Tizen.WebView { void Handler(object sender, global::Tizen.WebView.SmartCallbackArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UrlChanged += x, x => _data.UrlChanged -= x); + }, x => _data.UrlChanged += x, x => _data.UrlChanged -= x); } } @@ -7447,9 +6679,7 @@ namespace ElmSharp.Wearable { void Handler(global::ElmSharp.Wearable.RotaryEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::ElmSharp.Wearable.RotaryEventManager.Rotated += x, x => global::ElmSharp.Wearable.RotaryEventManager.Rotated -= x); + }, x => global::ElmSharp.Wearable.RotaryEventManager.Rotated += x, x => global::ElmSharp.Wearable.RotaryEventManager.Rotated -= x); } } @@ -7467,9 +6697,7 @@ namespace Tizen.Account.AccountManager { void Handler(object sender, global::Tizen.Account.AccountManager.AccountSubscriberEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Account.AccountManager.AccountService.AccountUpdated += x, x => global::Tizen.Account.AccountManager.AccountService.AccountUpdated -= x); + }, x => global::Tizen.Account.AccountManager.AccountService.AccountUpdated += x, x => global::Tizen.Account.AccountManager.AccountService.AccountUpdated -= x); } } @@ -7487,9 +6715,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.ApplicationDisabledEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.ApplicationManager.ApplicationDisabled += x, x => global::Tizen.Applications.ApplicationManager.ApplicationDisabled -= x); + }, x => global::Tizen.Applications.ApplicationManager.ApplicationDisabled += x, x => global::Tizen.Applications.ApplicationManager.ApplicationDisabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7497,9 +6723,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.ApplicationEnabledEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.ApplicationManager.ApplicationEnabled += x, x => global::Tizen.Applications.ApplicationManager.ApplicationEnabled -= x); + }, x => global::Tizen.Applications.ApplicationManager.ApplicationEnabled += x, x => global::Tizen.Applications.ApplicationManager.ApplicationEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7507,9 +6731,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.ApplicationLaunchedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.ApplicationManager.ApplicationLaunched += x, x => global::Tizen.Applications.ApplicationManager.ApplicationLaunched -= x); + }, x => global::Tizen.Applications.ApplicationManager.ApplicationLaunched += x, x => global::Tizen.Applications.ApplicationManager.ApplicationLaunched -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7517,9 +6739,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.ApplicationTerminatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.ApplicationManager.ApplicationTerminated += x, x => global::Tizen.Applications.ApplicationManager.ApplicationTerminated -= x); + }, x => global::Tizen.Applications.ApplicationManager.ApplicationTerminated += x, x => global::Tizen.Applications.ApplicationManager.ApplicationTerminated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7527,9 +6747,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.BadgeEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.BadgeControl.Changed += x, x => global::Tizen.Applications.BadgeControl.Changed -= x); + }, x => global::Tizen.Applications.BadgeControl.Changed += x, x => global::Tizen.Applications.BadgeControl.Changed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7537,9 +6755,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.PackageManagerEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.PackageManager.ClearDataProgressChanged += x, x => global::Tizen.Applications.PackageManager.ClearDataProgressChanged -= x); + }, x => global::Tizen.Applications.PackageManager.ClearDataProgressChanged += x, x => global::Tizen.Applications.PackageManager.ClearDataProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7547,9 +6763,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.PackageManagerEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.PackageManager.InstallProgressChanged += x, x => global::Tizen.Applications.PackageManager.InstallProgressChanged -= x); + }, x => global::Tizen.Applications.PackageManager.InstallProgressChanged += x, x => global::Tizen.Applications.PackageManager.InstallProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7557,9 +6771,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.PackageManagerEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.PackageManager.MoveProgressChanged += x, x => global::Tizen.Applications.PackageManager.MoveProgressChanged -= x); + }, x => global::Tizen.Applications.PackageManager.MoveProgressChanged += x, x => global::Tizen.Applications.PackageManager.MoveProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7567,9 +6779,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.PackageManagerEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.PackageManager.UninstallProgressChanged += x, x => global::Tizen.Applications.PackageManager.UninstallProgressChanged -= x); + }, x => global::Tizen.Applications.PackageManager.UninstallProgressChanged += x, x => global::Tizen.Applications.PackageManager.UninstallProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7577,9 +6787,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.PackageManagerEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.PackageManager.UpdateProgressChanged += x, x => global::Tizen.Applications.PackageManager.UpdateProgressChanged -= x); + }, x => global::Tizen.Applications.PackageManager.UpdateProgressChanged += x, x => global::Tizen.Applications.PackageManager.UpdateProgressChanged -= x); } } @@ -7597,9 +6805,7 @@ namespace Tizen.Applications.NotificationEventListener { void Handler(object sender, global::Tizen.Applications.NotificationEventListener.NotificationEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Added += x, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Added -= x); + }, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Added += x, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7607,9 +6813,7 @@ namespace Tizen.Applications.NotificationEventListener { void Handler(object sender, global::Tizen.Applications.NotificationEventListener.NotificationDeleteEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Deleted += x, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Deleted -= x); + }, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Deleted += x, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Deleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7617,9 +6821,7 @@ namespace Tizen.Applications.NotificationEventListener { void Handler(object sender, global::Tizen.Applications.NotificationEventListener.NotificationEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Updated += x, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Updated -= x); + }, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Updated += x, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Updated -= x); } } @@ -7637,9 +6839,7 @@ namespace Tizen.Content.MediaContent { void Handler(object sender, global::Tizen.Content.MediaContent.FolderUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Content.MediaContent.MediaDatabase.FolderUpdated += x, x => global::Tizen.Content.MediaContent.MediaDatabase.FolderUpdated -= x); + }, x => global::Tizen.Content.MediaContent.MediaDatabase.FolderUpdated += x, x => global::Tizen.Content.MediaContent.MediaDatabase.FolderUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7647,9 +6847,7 @@ namespace Tizen.Content.MediaContent { void Handler(object sender, global::Tizen.Content.MediaContent.MediaInfoUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Content.MediaContent.MediaDatabase.MediaInfoUpdated += x, x => global::Tizen.Content.MediaContent.MediaDatabase.MediaInfoUpdated -= x); + }, x => global::Tizen.Content.MediaContent.MediaDatabase.MediaInfoUpdated += x, x => global::Tizen.Content.MediaContent.MediaDatabase.MediaInfoUpdated -= x); } } @@ -7667,9 +6865,7 @@ namespace Tizen.Messaging.Messages { void Handler(object sender, global::Tizen.Messaging.Messages.MessageReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Messaging.Messages.MessagesManager.MessageReceived += x, x => global::Tizen.Messaging.Messages.MessagesManager.MessageReceived -= x); + }, x => global::Tizen.Messaging.Messages.MessagesManager.MessageReceived += x, x => global::Tizen.Messaging.Messages.MessagesManager.MessageReceived -= x); } } @@ -7687,9 +6883,7 @@ namespace Tizen.Messaging.Push { void Handler(object sender, global::Tizen.Messaging.Push.PushMessageEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Messaging.Push.PushClient.NotificationReceived += x, x => global::Tizen.Messaging.Push.PushClient.NotificationReceived -= x); + }, x => global::Tizen.Messaging.Push.PushClient.NotificationReceived += x, x => global::Tizen.Messaging.Push.PushClient.NotificationReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7697,9 +6891,7 @@ namespace Tizen.Messaging.Push { void Handler(object sender, global::Tizen.Messaging.Push.PushConnectionStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Messaging.Push.PushClient.StateChanged += x, x => global::Tizen.Messaging.Push.PushClient.StateChanged -= x); + }, x => global::Tizen.Messaging.Push.PushClient.StateChanged += x, x => global::Tizen.Messaging.Push.PushClient.StateChanged -= x); } } @@ -7717,9 +6909,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioDeviceConnectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Multimedia.AudioManager.DeviceConnectionChanged += x, x => global::Tizen.Multimedia.AudioManager.DeviceConnectionChanged -= x); + }, x => global::Tizen.Multimedia.AudioManager.DeviceConnectionChanged += x, x => global::Tizen.Multimedia.AudioManager.DeviceConnectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7727,9 +6917,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioDeviceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Multimedia.AudioManager.DeviceStateChanged += x, x => global::Tizen.Multimedia.AudioManager.DeviceStateChanged -= x); + }, x => global::Tizen.Multimedia.AudioManager.DeviceStateChanged += x, x => global::Tizen.Multimedia.AudioManager.DeviceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7737,9 +6925,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.StreamFocusStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Multimedia.AudioStreamPolicy.StreamFocusStateChanged += x, x => global::Tizen.Multimedia.AudioStreamPolicy.StreamFocusStateChanged -= x); + }, x => global::Tizen.Multimedia.AudioStreamPolicy.StreamFocusStateChanged += x, x => global::Tizen.Multimedia.AudioStreamPolicy.StreamFocusStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7747,9 +6933,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.CameraDeviceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Multimedia.Camera.DeviceStateChanged += x, x => global::Tizen.Multimedia.Camera.DeviceStateChanged -= x); + }, x => global::Tizen.Multimedia.Camera.DeviceStateChanged += x, x => global::Tizen.Multimedia.Camera.DeviceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7757,9 +6941,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecorderDeviceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Multimedia.Recorder.DeviceStateChanged += x, x => global::Tizen.Multimedia.Recorder.DeviceStateChanged -= x); + }, x => global::Tizen.Multimedia.Recorder.DeviceStateChanged += x, x => global::Tizen.Multimedia.Recorder.DeviceStateChanged -= x); } } @@ -7777,9 +6959,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.PlaybackCommandReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Multimedia.Remoting.MediaControlServer.PlaybackCommandReceived += x, x => global::Tizen.Multimedia.Remoting.MediaControlServer.PlaybackCommandReceived -= x); + }, x => global::Tizen.Multimedia.Remoting.MediaControlServer.PlaybackCommandReceived += x, x => global::Tizen.Multimedia.Remoting.MediaControlServer.PlaybackCommandReceived -= x); } } @@ -7797,9 +6977,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.DiscoveryStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Bluetooth.BluetoothAdapter.DiscoveryStateChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.DiscoveryStateChanged -= x); + }, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.DiscoveryStateChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.DiscoveryStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7807,9 +6985,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.NameChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Bluetooth.BluetoothAdapter.NameChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.NameChanged -= x); + }, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.NameChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.NameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7817,9 +6993,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.AdapterLeScanResultChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Bluetooth.BluetoothAdapter.ScanResultChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.ScanResultChanged -= x); + }, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.ScanResultChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.ScanResultChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7827,9 +7001,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Bluetooth.BluetoothAdapter.StateChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.StateChanged -= x); + }, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.StateChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.StateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7837,9 +7009,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.VisibilityDurationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityDurationChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityDurationChanged -= x); + }, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityDurationChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityDurationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7847,9 +7017,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.VisibilityModeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityModeChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityModeChanged -= x); + }, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityModeChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityModeChanged -= x); } } @@ -7867,9 +7035,7 @@ namespace Tizen.Network.Connection { void Handler(object sender, global::Tizen.Network.Connection.ConnectionTypeEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Connection.ConnectionManager.ConnectionTypeChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.ConnectionTypeChanged -= x); + }, x => global::Tizen.Network.Connection.ConnectionManager.ConnectionTypeChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.ConnectionTypeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7877,9 +7043,7 @@ namespace Tizen.Network.Connection { void Handler(object sender, global::Tizen.Network.Connection.EthernetCableStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Connection.ConnectionManager.EthernetCableStateChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.EthernetCableStateChanged -= x); + }, x => global::Tizen.Network.Connection.ConnectionManager.EthernetCableStateChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.EthernetCableStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7887,9 +7051,7 @@ namespace Tizen.Network.Connection { void Handler(object sender, global::Tizen.Network.Connection.AddressEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Connection.ConnectionManager.IPAddressChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.IPAddressChanged -= x); + }, x => global::Tizen.Network.Connection.ConnectionManager.IPAddressChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.IPAddressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7897,9 +7059,7 @@ namespace Tizen.Network.Connection { void Handler(object sender, global::Tizen.Network.Connection.AddressEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Connection.ConnectionManager.ProxyAddressChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.ProxyAddressChanged -= x); + }, x => global::Tizen.Network.Connection.ConnectionManager.ProxyAddressChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.ProxyAddressChanged -= x); } } @@ -7917,9 +7077,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.DeviceInformationFoundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.DeviceInformationFound += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.DeviceInformationFound -= x); + }, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.DeviceInformationFound += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.DeviceInformationFound -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7927,9 +7085,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.FindingErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.FindingErrorOccurred += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.FindingErrorOccurred -= x); + }, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.FindingErrorOccurred += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.FindingErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7937,9 +7093,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.PlatformInformationFoundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PlatformInformationFound += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PlatformInformationFound -= x); + }, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PlatformInformationFound += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PlatformInformationFound -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7947,9 +7101,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.PresenceReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PresenceReceived += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PresenceReceived -= x); + }, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PresenceReceived += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PresenceReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7957,9 +7109,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.ResourceFoundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.ResourceFound += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.ResourceFound -= x); + }, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.ResourceFound += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.ResourceFound -= x); } } @@ -7977,9 +7127,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.ActivationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Nfc.NfcManager.ActivationChanged += x, x => global::Tizen.Network.Nfc.NfcManager.ActivationChanged -= x); + }, x => global::Tizen.Network.Nfc.NfcManager.ActivationChanged += x, x => global::Tizen.Network.Nfc.NfcManager.ActivationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7987,9 +7135,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.NdefMessageDiscoveredEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Nfc.NfcManager.NdefMessageDiscovered += x, x => global::Tizen.Network.Nfc.NfcManager.NdefMessageDiscovered -= x); + }, x => global::Tizen.Network.Nfc.NfcManager.NdefMessageDiscovered += x, x => global::Tizen.Network.Nfc.NfcManager.NdefMessageDiscovered -= x); } } @@ -8007,9 +7153,7 @@ namespace Tizen.Network.WiFi { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFi.WiFiManager.BackgroundScanFinished += x, x => global::Tizen.Network.WiFi.WiFiManager.BackgroundScanFinished -= x); + }, x => global::Tizen.Network.WiFi.WiFiManager.BackgroundScanFinished += x, x => global::Tizen.Network.WiFi.WiFiManager.BackgroundScanFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8017,9 +7161,7 @@ namespace Tizen.Network.WiFi { void Handler(object sender, global::Tizen.Network.WiFi.ConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFi.WiFiManager.ConnectionStateChanged += x, x => global::Tizen.Network.WiFi.WiFiManager.ConnectionStateChanged -= x); + }, x => global::Tizen.Network.WiFi.WiFiManager.ConnectionStateChanged += x, x => global::Tizen.Network.WiFi.WiFiManager.ConnectionStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8027,9 +7169,7 @@ namespace Tizen.Network.WiFi { void Handler(object sender, global::Tizen.Network.WiFi.DeviceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFi.WiFiManager.DeviceStateChanged += x, x => global::Tizen.Network.WiFi.WiFiManager.DeviceStateChanged -= x); + }, x => global::Tizen.Network.WiFi.WiFiManager.DeviceStateChanged += x, x => global::Tizen.Network.WiFi.WiFiManager.DeviceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8037,9 +7177,7 @@ namespace Tizen.Network.WiFi { void Handler(object sender, global::Tizen.Network.WiFi.RssiLevelChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFi.WiFiManager.RssiLevelChanged += x, x => global::Tizen.Network.WiFi.WiFiManager.RssiLevelChanged -= x); + }, x => global::Tizen.Network.WiFi.WiFiManager.RssiLevelChanged += x, x => global::Tizen.Network.WiFi.WiFiManager.RssiLevelChanged -= x); } } @@ -8057,9 +7195,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.ConnectionStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.ConnectionStatusChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.ConnectionStatusChanged -= x); + }, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.ConnectionStatusChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.ConnectionStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8067,9 +7203,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.DeviceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DeviceStateChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DeviceStateChanged -= x); + }, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DeviceStateChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DeviceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8077,9 +7211,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.DiscoveryStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DiscoveryStateChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DiscoveryStateChanged -= x); + }, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DiscoveryStateChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DiscoveryStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8087,9 +7219,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.PeerFoundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.PeerFound += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.PeerFound -= x); + }, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.PeerFound += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.PeerFound -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8097,9 +7227,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.StateChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.StateChanged -= x); + }, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.StateChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.StateChanged -= x); } } @@ -8117,9 +7245,7 @@ namespace Tizen.Pims.Calendar { void Handler(object sender, global::Tizen.Pims.Calendar.ReminderAlertedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Pims.Calendar.CalendarReminder.ReminderAlerted += x, x => global::Tizen.Pims.Calendar.CalendarReminder.ReminderAlerted -= x); + }, x => global::Tizen.Pims.Calendar.CalendarReminder.ReminderAlerted += x, x => global::Tizen.Pims.Calendar.CalendarReminder.ReminderAlerted -= x); } } @@ -8137,9 +7263,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.BatteryChargingStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.Battery.ChargingStateChanged += x, x => global::Tizen.System.Battery.ChargingStateChanged -= x); + }, x => global::Tizen.System.Battery.ChargingStateChanged += x, x => global::Tizen.System.Battery.ChargingStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8147,9 +7271,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.BatteryLevelChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.Battery.LevelChanged += x, x => global::Tizen.System.Battery.LevelChanged -= x); + }, x => global::Tizen.System.Battery.LevelChanged += x, x => global::Tizen.System.Battery.LevelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8157,9 +7279,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.BatteryPercentChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.Battery.PercentChanged += x, x => global::Tizen.System.Battery.PercentChanged -= x); + }, x => global::Tizen.System.Battery.PercentChanged += x, x => global::Tizen.System.Battery.PercentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8167,9 +7287,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.DisplayStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.Display.StateChanged += x, x => global::Tizen.System.Display.StateChanged -= x); + }, x => global::Tizen.System.Display.StateChanged += x, x => global::Tizen.System.Display.StateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8177,9 +7295,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.LedBrightnessChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.Led.BrightnessChanged += x, x => global::Tizen.System.Led.BrightnessChanged -= x); + }, x => global::Tizen.System.Led.BrightnessChanged += x, x => global::Tizen.System.Led.BrightnessChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8187,9 +7303,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.MediaKeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.MediaKey.Event += x, x => global::Tizen.System.MediaKey.Event -= x); + }, x => global::Tizen.System.MediaKey.Event += x, x => global::Tizen.System.MediaKey.Event -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8197,9 +7311,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.AccessibilityTtsSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.AccessibilityTtsSettingChanged += x, x => global::Tizen.System.SystemSettings.AccessibilityTtsSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.AccessibilityTtsSettingChanged += x, x => global::Tizen.System.SystemSettings.AccessibilityTtsSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8207,9 +7319,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.AdsIdChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.AdsIdChanged += x, x => global::Tizen.System.SystemSettings.AdsIdChanged -= x); + }, x => global::Tizen.System.SystemSettings.AdsIdChanged += x, x => global::Tizen.System.SystemSettings.AdsIdChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8217,9 +7327,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.Data3GNetworkSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.Data3GNetworkSettingChanged += x, x => global::Tizen.System.SystemSettings.Data3GNetworkSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.Data3GNetworkSettingChanged += x, x => global::Tizen.System.SystemSettings.Data3GNetworkSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8227,9 +7335,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.DeviceNameChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.DeviceNameChanged += x, x => global::Tizen.System.SystemSettings.DeviceNameChanged -= x); + }, x => global::Tizen.System.SystemSettings.DeviceNameChanged += x, x => global::Tizen.System.SystemSettings.DeviceNameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8237,9 +7343,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.DisplayScreenRotationAutoSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.DisplayScreenRotationAutoSettingChanged += x, x => global::Tizen.System.SystemSettings.DisplayScreenRotationAutoSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.DisplayScreenRotationAutoSettingChanged += x, x => global::Tizen.System.SystemSettings.DisplayScreenRotationAutoSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8247,9 +7351,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.EmailAlertRingtoneChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.EmailAlertRingtoneChanged += x, x => global::Tizen.System.SystemSettings.EmailAlertRingtoneChanged -= x); + }, x => global::Tizen.System.SystemSettings.EmailAlertRingtoneChanged += x, x => global::Tizen.System.SystemSettings.EmailAlertRingtoneChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8257,9 +7359,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.FontSizeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.FontSizeChanged += x, x => global::Tizen.System.SystemSettings.FontSizeChanged -= x); + }, x => global::Tizen.System.SystemSettings.FontSizeChanged += x, x => global::Tizen.System.SystemSettings.FontSizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8267,9 +7367,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.FontTypeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.FontTypeChanged += x, x => global::Tizen.System.SystemSettings.FontTypeChanged -= x); + }, x => global::Tizen.System.SystemSettings.FontTypeChanged += x, x => global::Tizen.System.SystemSettings.FontTypeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8277,9 +7375,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.IncomingCallRingtoneChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.IncomingCallRingtoneChanged += x, x => global::Tizen.System.SystemSettings.IncomingCallRingtoneChanged -= x); + }, x => global::Tizen.System.SystemSettings.IncomingCallRingtoneChanged += x, x => global::Tizen.System.SystemSettings.IncomingCallRingtoneChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8287,9 +7383,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.LocaleCountryChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.LocaleCountryChanged += x, x => global::Tizen.System.SystemSettings.LocaleCountryChanged -= x); + }, x => global::Tizen.System.SystemSettings.LocaleCountryChanged += x, x => global::Tizen.System.SystemSettings.LocaleCountryChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8297,9 +7391,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.LocaleLanguageChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.LocaleLanguageChanged += x, x => global::Tizen.System.SystemSettings.LocaleLanguageChanged -= x); + }, x => global::Tizen.System.SystemSettings.LocaleLanguageChanged += x, x => global::Tizen.System.SystemSettings.LocaleLanguageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8307,9 +7399,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.LocaleTimeFormat24HourSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.LocaleTimeFormat24HourSettingChanged += x, x => global::Tizen.System.SystemSettings.LocaleTimeFormat24HourSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.LocaleTimeFormat24HourSettingChanged += x, x => global::Tizen.System.SystemSettings.LocaleTimeFormat24HourSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8317,9 +7407,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.LocaleTimeZoneChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.LocaleTimeZoneChanged += x, x => global::Tizen.System.SystemSettings.LocaleTimeZoneChanged -= x); + }, x => global::Tizen.System.SystemSettings.LocaleTimeZoneChanged += x, x => global::Tizen.System.SystemSettings.LocaleTimeZoneChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8327,9 +7415,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.LockScreenAppChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.LockScreenAppChanged += x, x => global::Tizen.System.SystemSettings.LockScreenAppChanged -= x); + }, x => global::Tizen.System.SystemSettings.LockScreenAppChanged += x, x => global::Tizen.System.SystemSettings.LockScreenAppChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8337,9 +7423,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.LockStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.LockStateChanged += x, x => global::Tizen.System.SystemSettings.LockStateChanged -= x); + }, x => global::Tizen.System.SystemSettings.LockStateChanged += x, x => global::Tizen.System.SystemSettings.LockStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8347,9 +7431,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.MotionActivationSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.MotionActivationSettingChanged += x, x => global::Tizen.System.SystemSettings.MotionActivationSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.MotionActivationSettingChanged += x, x => global::Tizen.System.SystemSettings.MotionActivationSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8357,9 +7439,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.MotionSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.MotionSettingChanged += x, x => global::Tizen.System.SystemSettings.MotionSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.MotionSettingChanged += x, x => global::Tizen.System.SystemSettings.MotionSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8367,9 +7447,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.NetworkFlightModeSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.NetworkFlightModeSettingChanged += x, x => global::Tizen.System.SystemSettings.NetworkFlightModeSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.NetworkFlightModeSettingChanged += x, x => global::Tizen.System.SystemSettings.NetworkFlightModeSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8377,9 +7455,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.NetworkWifiNotificationSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.NetworkWifiNotificationSettingChanged += x, x => global::Tizen.System.SystemSettings.NetworkWifiNotificationSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.NetworkWifiNotificationSettingChanged += x, x => global::Tizen.System.SystemSettings.NetworkWifiNotificationSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8387,9 +7463,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.ScreenBacklightTimeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.ScreenBacklightTimeChanged += x, x => global::Tizen.System.SystemSettings.ScreenBacklightTimeChanged -= x); + }, x => global::Tizen.System.SystemSettings.ScreenBacklightTimeChanged += x, x => global::Tizen.System.SystemSettings.ScreenBacklightTimeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8397,9 +7471,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.SoundLockSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.SoundLockSettingChanged += x, x => global::Tizen.System.SystemSettings.SoundLockSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.SoundLockSettingChanged += x, x => global::Tizen.System.SystemSettings.SoundLockSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8407,9 +7479,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.SoundNotificationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.SoundNotificationChanged += x, x => global::Tizen.System.SystemSettings.SoundNotificationChanged -= x); + }, x => global::Tizen.System.SystemSettings.SoundNotificationChanged += x, x => global::Tizen.System.SystemSettings.SoundNotificationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8417,9 +7487,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.SoundNotificationRepetitionPeriodChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.SoundNotificationRepetitionPeriodChanged += x, x => global::Tizen.System.SystemSettings.SoundNotificationRepetitionPeriodChanged -= x); + }, x => global::Tizen.System.SystemSettings.SoundNotificationRepetitionPeriodChanged += x, x => global::Tizen.System.SystemSettings.SoundNotificationRepetitionPeriodChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8427,9 +7495,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.SoundSilentModeSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.SoundSilentModeSettingChanged += x, x => global::Tizen.System.SystemSettings.SoundSilentModeSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.SoundSilentModeSettingChanged += x, x => global::Tizen.System.SystemSettings.SoundSilentModeSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8437,9 +7503,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.SoundTouchSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.SoundTouchSettingChanged += x, x => global::Tizen.System.SystemSettings.SoundTouchSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.SoundTouchSettingChanged += x, x => global::Tizen.System.SystemSettings.SoundTouchSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8447,9 +7511,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.TimeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.TimeChanged += x, x => global::Tizen.System.SystemSettings.TimeChanged -= x); + }, x => global::Tizen.System.SystemSettings.TimeChanged += x, x => global::Tizen.System.SystemSettings.TimeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8457,9 +7519,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.UltraDataSaveChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.UltraDataSaveChanged += x, x => global::Tizen.System.SystemSettings.UltraDataSaveChanged -= x); + }, x => global::Tizen.System.SystemSettings.UltraDataSaveChanged += x, x => global::Tizen.System.SystemSettings.UltraDataSaveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8467,9 +7527,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.UltraDataSavePackageListChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.UltraDataSavePackageListChanged += x, x => global::Tizen.System.SystemSettings.UltraDataSavePackageListChanged -= x); + }, x => global::Tizen.System.SystemSettings.UltraDataSavePackageListChanged += x, x => global::Tizen.System.SystemSettings.UltraDataSavePackageListChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8477,9 +7535,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.UsbDebuggingSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.UsbDebuggingSettingChanged += x, x => global::Tizen.System.SystemSettings.UsbDebuggingSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.UsbDebuggingSettingChanged += x, x => global::Tizen.System.SystemSettings.UsbDebuggingSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8487,9 +7543,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.WallpaperHomeScreenChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.WallpaperHomeScreenChanged += x, x => global::Tizen.System.SystemSettings.WallpaperHomeScreenChanged -= x); + }, x => global::Tizen.System.SystemSettings.WallpaperHomeScreenChanged += x, x => global::Tizen.System.SystemSettings.WallpaperHomeScreenChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8497,9 +7551,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.WallpaperLockScreenChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.WallpaperLockScreenChanged += x, x => global::Tizen.System.SystemSettings.WallpaperLockScreenChanged -= x); + }, x => global::Tizen.System.SystemSettings.WallpaperLockScreenChanged += x, x => global::Tizen.System.SystemSettings.WallpaperLockScreenChanged -= x); } } @@ -8517,9 +7569,7 @@ namespace Tizen.Telephony { void Handler(object sender, global::Tizen.Telephony.StateEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Telephony.Manager.StateChanged += x, x => global::Tizen.Telephony.Manager.StateChanged -= x); + }, x => global::Tizen.Telephony.Manager.StateChanged += x, x => global::Tizen.Telephony.Manager.StateChanged -= x); } } @@ -8537,9 +7587,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.AccessibilityStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.AccessibilityStateChanged += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.AccessibilityStateChanged -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.AccessibilityStateChanged += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.AccessibilityStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8547,9 +7595,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.CursorPositionUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.CursorPositionUpdated += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.CursorPositionUpdated -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.CursorPositionUpdated += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.CursorPositionUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8557,9 +7603,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.SetDataEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.DataSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.DataSet -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.DataSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.DataSet -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8567,9 +7611,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.DisplayLanguageChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.DisplayLanguageChanged += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.DisplayLanguageChanged -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.DisplayLanguageChanged += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.DisplayLanguageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8577,9 +7619,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.FocusedInEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedIn += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedIn -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedIn += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedIn -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8587,9 +7627,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.FocusedOutEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedOut += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedOut -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedOut += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedOut -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8597,9 +7635,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.InputContextReset += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.InputContextReset -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.InputContextReset += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.InputContextReset -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8607,9 +7643,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.LanguageSetEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.LanguageSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.LanguageSet -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.LanguageSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.LanguageSet -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8617,9 +7651,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.LayoutSetEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.LayoutSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.LayoutSet -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.LayoutSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.LayoutSet -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8627,9 +7659,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.ReturnKeySetEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeySet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeySet -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeySet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeySet -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8637,9 +7667,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.ReturnKeyStateSetEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeyStateSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeyStateSet -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeyStateSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeyStateSet -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8647,9 +7675,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.RotationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.RotationChanged += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.RotationChanged -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.RotationChanged += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.RotationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8657,9 +7683,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.SurroundingTextUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.SurroundingTextUpdated += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.SurroundingTextUpdated -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.SurroundingTextUpdated += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.SurroundingTextUpdated -= x); } } @@ -8677,9 +7701,7 @@ namespace Tizen.Uix.VoiceControl { void Handler(object sender, global::Tizen.Uix.VoiceControl.CurrentLanguageChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.VoiceControl.VoiceControlClient.CurrentLanguageChanged += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.CurrentLanguageChanged -= x); + }, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.CurrentLanguageChanged += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.CurrentLanguageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8687,9 +7709,7 @@ namespace Tizen.Uix.VoiceControl { void Handler(object sender, global::Tizen.Uix.VoiceControl.ErrorOccuredEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ErrorOccured += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ErrorOccured -= x); + }, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ErrorOccured += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ErrorOccured -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8697,9 +7717,7 @@ namespace Tizen.Uix.VoiceControl { void Handler(object sender, global::Tizen.Uix.VoiceControl.RecognitionResultEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.VoiceControl.VoiceControlClient.RecognitionResult += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.RecognitionResult -= x); + }, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.RecognitionResult += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.RecognitionResult -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8707,9 +7725,7 @@ namespace Tizen.Uix.VoiceControl { void Handler(object sender, global::Tizen.Uix.VoiceControl.ServiceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ServiceStateChanged += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ServiceStateChanged -= x); + }, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ServiceStateChanged += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ServiceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8717,8 +7733,6 @@ namespace Tizen.Uix.VoiceControl { void Handler(object sender, global::Tizen.Uix.VoiceControl.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.VoiceControl.VoiceControlClient.StateChanged += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.StateChanged -= x); + }, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.StateChanged += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.StateChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Tizen.NET.API4.4.0.1.14164.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Tizen.NET.API4.4.0.1.14164.netstandard2.0.approved.txt index 25db7a8..f2adef8 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Tizen.NET.API4.4.0.1.14164.netstandard2.0.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Tizen.NET.API4.4.0.1.14164.netstandard2.0.approved.txt @@ -204,9 +204,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -214,9 +212,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -224,9 +220,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -234,9 +228,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Repeated += x, x => _data.Repeated -= x); + }, x => _data.Repeated += x, x => _data.Repeated -= x); } /// @@ -261,9 +253,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateChanged += x, x => _data.DateChanged -= x); + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -271,9 +261,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.DisplayedMonthChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayedMonthChanged += x, x => _data.DisplayedMonthChanged -= x); + }, x => _data.DisplayedMonthChanged += x, x => _data.DisplayedMonthChanged -= x); } /// @@ -298,9 +286,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.CheckStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -325,9 +311,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.ColorChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); } /// @@ -352,9 +336,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); } /// @@ -379,9 +361,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } /// @@ -406,9 +386,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); + }, x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); } /// @@ -433,9 +411,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Finished += x, x => _data.Finished -= x); + }, x => _data.Finished += x, x => _data.Finished -= x); } /// @@ -460,9 +436,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EffectEnded += x, x => _data.EffectEnded -= x); + }, x => _data.EffectEnded += x, x => _data.EffectEnded -= x); } /// @@ -487,9 +461,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -497,9 +469,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChangedByUser += x, x => _data.ChangedByUser -= x); + }, x => _data.ChangedByUser += x, x => _data.ChangedByUser -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -507,9 +477,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -517,9 +485,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); } /// @@ -544,9 +510,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -554,9 +518,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Deleted += x, x => _data.Deleted -= x); + }, x => _data.Deleted += x, x => _data.Deleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -564,9 +526,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -574,9 +534,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -584,9 +542,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MoreButtonPressed += x, x => _data.MoreButtonPressed -= x); + }, x => _data.MoreButtonPressed += x, x => _data.MoreButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -594,9 +550,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Moved += x, x => _data.Moved -= x); + }, x => _data.Moved += x, x => _data.Moved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -604,9 +558,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RenderPost += x, x => _data.RenderPost -= x); + }, x => _data.RenderPost += x, x => _data.RenderPost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -614,9 +566,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resized += x, x => _data.Resized -= x); + }, x => _data.Resized += x, x => _data.Resized -= x); } /// @@ -641,9 +591,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.On += x, x => _data.On -= x); + }, x => _data.On += x, x => _data.On -= x); } /// @@ -668,9 +616,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Overflowed += x, x => _data.Overflowed -= x); + }, x => _data.Overflowed += x, x => _data.Overflowed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -678,9 +624,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -688,9 +632,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Underflowed += x, x => _data.Underflowed -= x); + }, x => _data.Underflowed += x, x => _data.Underflowed -= x); } /// @@ -715,9 +657,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } /// @@ -742,9 +682,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -752,9 +690,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemActivated += x, x => _data.ItemActivated -= x); + }, x => _data.ItemActivated += x, x => _data.ItemActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -762,9 +698,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDoubleClicked += x, x => _data.ItemDoubleClicked -= x); + }, x => _data.ItemDoubleClicked += x, x => _data.ItemDoubleClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -772,9 +706,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -782,9 +714,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemPressed += x, x => _data.ItemPressed -= x); + }, x => _data.ItemPressed += x, x => _data.ItemPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -792,9 +722,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemRealized += x, x => _data.ItemRealized -= x); + }, x => _data.ItemRealized += x, x => _data.ItemRealized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -802,9 +730,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemReleased += x, x => _data.ItemReleased -= x); + }, x => _data.ItemReleased += x, x => _data.ItemReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -812,9 +738,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -822,9 +746,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemUnrealized += x, x => _data.ItemUnrealized -= x); + }, x => _data.ItemUnrealized += x, x => _data.ItemUnrealized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -832,9 +754,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenGridItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemUnselected += x, x => _data.ItemUnselected -= x); + }, x => _data.ItemUnselected += x, x => _data.ItemUnselected -= x); } /// @@ -859,9 +779,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -869,9 +787,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemActivated += x, x => _data.ItemActivated -= x); + }, x => _data.ItemActivated += x, x => _data.ItemActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -879,9 +795,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDoubleClicked += x, x => _data.ItemDoubleClicked -= x); + }, x => _data.ItemDoubleClicked += x, x => _data.ItemDoubleClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -889,9 +803,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemExpanded += x, x => _data.ItemExpanded -= x); + }, x => _data.ItemExpanded += x, x => _data.ItemExpanded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -899,9 +811,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -909,9 +819,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemMoved += x, x => _data.ItemMoved -= x); + }, x => _data.ItemMoved += x, x => _data.ItemMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -919,9 +827,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemMovedAfter += x, x => _data.ItemMovedAfter -= x); + }, x => _data.ItemMovedAfter += x, x => _data.ItemMovedAfter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -929,9 +835,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemMovedBefore += x, x => _data.ItemMovedBefore -= x); + }, x => _data.ItemMovedBefore += x, x => _data.ItemMovedBefore -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -939,9 +843,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemPressed += x, x => _data.ItemPressed -= x); + }, x => _data.ItemPressed += x, x => _data.ItemPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -949,9 +851,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemRealized += x, x => _data.ItemRealized -= x); + }, x => _data.ItemRealized += x, x => _data.ItemRealized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -959,9 +859,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemReleased += x, x => _data.ItemReleased -= x); + }, x => _data.ItemReleased += x, x => _data.ItemReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -969,9 +867,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -979,9 +875,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemUnrealized += x, x => _data.ItemUnrealized -= x); + }, x => _data.ItemUnrealized += x, x => _data.ItemUnrealized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -989,9 +883,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemUnselected += x, x => _data.ItemUnselected -= x); + }, x => _data.ItemUnselected += x, x => _data.ItemUnselected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -999,9 +891,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollAnimationStarted += x, x => _data.ScrollAnimationStarted -= x); + }, x => _data.ScrollAnimationStarted += x, x => _data.ScrollAnimationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1009,9 +899,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollAnimationStopped += x, x => _data.ScrollAnimationStopped -= x); + }, x => _data.ScrollAnimationStopped += x, x => _data.ScrollAnimationStopped -= x); } /// @@ -1036,9 +924,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1046,9 +932,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1056,9 +940,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Expanded += x, x => _data.Expanded -= x); + }, x => _data.Expanded += x, x => _data.Expanded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1066,9 +948,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.HoverselItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -1093,9 +973,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -1120,9 +998,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1130,9 +1006,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadingCompleted += x, x => _data.LoadingCompleted -= x); + }, x => _data.LoadingCompleted += x, x => _data.LoadingCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1140,9 +1014,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadingFailed += x, x => _data.LoadingFailed -= x); + }, x => _data.LoadingFailed += x, x => _data.LoadingFailed -= x); } /// @@ -1167,9 +1039,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } /// @@ -1194,9 +1064,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } /// @@ -1221,9 +1089,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Deleted += x, x => _data.Deleted -= x); + }, x => _data.Deleted += x, x => _data.Deleted -= x); } /// @@ -1248,9 +1114,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SlideCompleted += x, x => _data.SlideCompleted -= x); + }, x => _data.SlideCompleted += x, x => _data.SlideCompleted -= x); } /// @@ -1275,9 +1139,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); + }, x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1285,9 +1147,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ThemeChanged += x, x => _data.ThemeChanged -= x); + }, x => _data.ThemeChanged += x, x => _data.ThemeChanged -= x); } /// @@ -1312,9 +1172,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.ListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemActivated += x, x => _data.ItemActivated -= x); + }, x => _data.ItemActivated += x, x => _data.ItemActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1322,9 +1180,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.ListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDoubleClicked += x, x => _data.ItemDoubleClicked -= x); + }, x => _data.ItemDoubleClicked += x, x => _data.ItemDoubleClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1332,9 +1188,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.ListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1342,9 +1196,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.ListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1352,9 +1204,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.ListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemUnselected += x, x => _data.ItemUnselected -= x); + }, x => _data.ItemUnselected += x, x => _data.ItemUnselected -= x); } /// @@ -1379,9 +1229,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1389,9 +1237,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Contracted += x, x => _data.Contracted -= x); + }, x => _data.Contracted += x, x => _data.Contracted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1399,9 +1245,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Expanded += x, x => _data.Expanded -= x); + }, x => _data.Expanded += x, x => _data.Expanded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1409,9 +1253,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ExpandedStateChanged += x, x => _data.ExpandedStateChanged -= x); + }, x => _data.ExpandedStateChanged += x, x => _data.ExpandedStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1419,9 +1261,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.MultiButtonEntryItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAdded += x, x => _data.ItemAdded -= x); + }, x => _data.ItemAdded += x, x => _data.ItemAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1429,9 +1269,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.MultiButtonEntryItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemClicked += x, x => _data.ItemClicked -= x); + }, x => _data.ItemClicked += x, x => _data.ItemClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1439,9 +1277,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.MultiButtonEntryItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDeleted += x, x => _data.ItemDeleted -= x); + }, x => _data.ItemDeleted += x, x => _data.ItemDeleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1449,9 +1285,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.MultiButtonEntryItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1459,9 +1293,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.MultiButtonEntryItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -1486,9 +1318,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); + }, x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1496,9 +1326,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.NaviframeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); } /// @@ -1523,9 +1351,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); } /// @@ -1550,9 +1376,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -1577,9 +1401,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1587,9 +1409,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unpressed += x, x => _data.Unpressed -= x); + }, x => _data.Unpressed += x, x => _data.Unpressed -= x); } /// @@ -1614,9 +1434,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1624,9 +1442,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OutsideClicked += x, x => _data.OutsideClicked -= x); + }, x => _data.OutsideClicked += x, x => _data.OutsideClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1634,9 +1450,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ShowAnimationFinished += x, x => _data.ShowAnimationFinished -= x); + }, x => _data.ShowAnimationFinished += x, x => _data.ShowAnimationFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1644,9 +1458,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TimedOut += x, x => _data.TimedOut -= x); + }, x => _data.TimedOut += x, x => _data.TimedOut -= x); } /// @@ -1671,9 +1483,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -1698,9 +1508,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -1725,9 +1533,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStart += x, x => _data.DragStart -= x); + }, x => _data.DragStart += x, x => _data.DragStart -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1735,9 +1541,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStop += x, x => _data.DragStop -= x); + }, x => _data.DragStop += x, x => _data.DragStop -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1745,9 +1549,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PageScrolled += x, x => _data.PageScrolled -= x); + }, x => _data.PageScrolled += x, x => _data.PageScrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1755,9 +1557,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); } /// @@ -1782,9 +1582,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DelayedValueChanged += x, x => _data.DelayedValueChanged -= x); + }, x => _data.DelayedValueChanged += x, x => _data.DelayedValueChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1792,9 +1590,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1802,9 +1598,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStopped += x, x => _data.DragStopped -= x); + }, x => _data.DragStopped += x, x => _data.DragStopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1812,9 +1606,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -1839,9 +1631,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.On += x, x => _data.On -= x); + }, x => _data.On += x, x => _data.On -= x); } /// @@ -1866,9 +1656,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DelayedValueChanged += x, x => _data.DelayedValueChanged -= x); + }, x => _data.DelayedValueChanged += x, x => _data.DelayedValueChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1876,9 +1664,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -1903,9 +1689,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.ToolbarItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } /// @@ -1930,9 +1714,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1940,9 +1722,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LongPressed += x, x => _data.LongPressed -= x); + }, x => _data.LongPressed += x, x => _data.LongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1950,9 +1730,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } /// @@ -1977,9 +1755,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Deleted += x, x => _data.Deleted -= x); + }, x => _data.Deleted += x, x => _data.Deleted -= x); } /// @@ -2004,9 +1780,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2014,9 +1788,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2041,9 +1813,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2051,9 +1821,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RotationChanged += x, x => _data.RotationChanged -= x); + }, x => _data.RotationChanged += x, x => _data.RotationChanged -= x); } } @@ -2100,9 +1868,7 @@ namespace ElmSharp.Wearable { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2127,9 +1893,7 @@ namespace ElmSharp.Wearable { void Handler(object sender, global::ElmSharp.Wearable.MoreOptionItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2137,9 +1901,7 @@ namespace ElmSharp.Wearable { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2147,9 +1909,7 @@ namespace ElmSharp.Wearable { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2157,9 +1917,7 @@ namespace ElmSharp.Wearable { void Handler(object sender, global::ElmSharp.Wearable.MoreOptionItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } /// @@ -2184,9 +1942,7 @@ namespace ElmSharp.Wearable { void Handler(object sender, global::ElmSharp.Wearable.RotarySelectorItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2194,9 +1950,7 @@ namespace ElmSharp.Wearable { void Handler(object sender, global::ElmSharp.Wearable.RotarySelectorItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } } @@ -2251,9 +2005,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.AppControlReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AppControlReceived += x, x => _data.AppControlReceived -= x); + }, x => _data.AppControlReceived += x, x => _data.AppControlReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2261,9 +2013,7 @@ namespace Tizen.Applications { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Created += x, x => _data.Created -= x); + }, x => _data.Created += x, x => _data.Created -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2271,9 +2021,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.DeviceOrientationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DeviceOrientationChanged += x, x => _data.DeviceOrientationChanged -= x); + }, x => _data.DeviceOrientationChanged += x, x => _data.DeviceOrientationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2281,9 +2029,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.LocaleChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LocaleChanged += x, x => _data.LocaleChanged -= x); + }, x => _data.LocaleChanged += x, x => _data.LocaleChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2291,9 +2037,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.LowBatteryEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LowBattery += x, x => _data.LowBattery -= x); + }, x => _data.LowBattery += x, x => _data.LowBattery -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2301,9 +2045,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.LowMemoryEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LowMemory += x, x => _data.LowMemory -= x); + }, x => _data.LowMemory += x, x => _data.LowMemory -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2311,9 +2053,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.RegionFormatChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RegionFormatChanged += x, x => _data.RegionFormatChanged -= x); + }, x => _data.RegionFormatChanged += x, x => _data.RegionFormatChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2321,9 +2061,7 @@ namespace Tizen.Applications { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Terminated += x, x => _data.Terminated -= x); + }, x => _data.Terminated += x, x => _data.Terminated -= x); } /// @@ -2348,9 +2086,7 @@ namespace Tizen.Applications { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paused += x, x => _data.Paused -= x); + }, x => _data.Paused += x, x => _data.Paused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2358,9 +2094,7 @@ namespace Tizen.Applications { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resumed += x, x => _data.Resumed -= x); + }, x => _data.Resumed += x, x => _data.Resumed -= x); } /// @@ -2385,9 +2119,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.PreferenceChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } /// @@ -2412,9 +2144,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.AmbientEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AmbientChanged += x, x => _data.AmbientChanged -= x); + }, x => _data.AmbientChanged += x, x => _data.AmbientChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2422,9 +2152,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.TimeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AmbientTick += x, x => _data.AmbientTick -= x); + }, x => _data.AmbientTick += x, x => _data.AmbientTick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2432,9 +2160,7 @@ namespace Tizen.Applications { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paused += x, x => _data.Paused -= x); + }, x => _data.Paused += x, x => _data.Paused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2442,9 +2168,7 @@ namespace Tizen.Applications { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resumed += x, x => _data.Resumed -= x); + }, x => _data.Resumed += x, x => _data.Resumed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2452,9 +2176,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.TimeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TimeTick += x, x => _data.TimeTick -= x); + }, x => _data.TimeTick += x, x => _data.TimeTick -= x); } /// @@ -2479,9 +2201,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.WidgetLifecycleEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Created += x, x => _data.Created -= x); + }, x => _data.Created += x, x => _data.Created -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2489,9 +2209,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.WidgetLifecycleEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2499,9 +2217,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.WidgetLifecycleEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paused += x, x => _data.Paused -= x); + }, x => _data.Paused += x, x => _data.Paused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2509,9 +2225,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.WidgetLifecycleEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resumed += x, x => _data.Resumed -= x); + }, x => _data.Resumed += x, x => _data.Resumed -= x); } } @@ -2550,9 +2264,7 @@ namespace Tizen.Applications.AttachPanel { void Handler(object sender, global::Tizen.Applications.AttachPanel.StateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EventChanged += x, x => _data.EventChanged -= x); + }, x => _data.EventChanged += x, x => _data.EventChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2560,9 +2272,7 @@ namespace Tizen.Applications.AttachPanel { void Handler(object sender, global::Tizen.Applications.AttachPanel.ResultEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResultCallback += x, x => _data.ResultCallback -= x); + }, x => _data.ResultCallback += x, x => _data.ResultCallback -= x); } } @@ -2605,9 +2315,7 @@ namespace Tizen.Applications.Messages { void Handler(object sender, global::Tizen.Applications.Messages.MessageReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } /// @@ -2632,9 +2340,7 @@ namespace Tizen.Applications.Messages { void Handler(object sender, global::Tizen.Applications.Messages.RemotePortStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemotePortStateChanged += x, x => _data.RemotePortStateChanged -= x); + }, x => _data.RemotePortStateChanged += x, x => _data.RemotePortStateChanged -= x); } } @@ -2673,9 +2379,7 @@ namespace Tizen.Content.Download { void Handler(object sender, global::Tizen.Content.Download.ProgressChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2683,9 +2387,7 @@ namespace Tizen.Content.Download { void Handler(object sender, global::Tizen.Content.Download.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -2728,9 +2430,7 @@ namespace Tizen.Location { void Handler(object sender, global::Tizen.Location.SatelliteStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SatelliteStatusUpdated += x, x => _data.SatelliteStatusUpdated -= x); + }, x => _data.SatelliteStatusUpdated += x, x => _data.SatelliteStatusUpdated -= x); } /// @@ -2755,9 +2455,7 @@ namespace Tizen.Location { void Handler(object sender, global::Tizen.Location.LocationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DistanceBasedLocationChanged += x, x => _data.DistanceBasedLocationChanged -= x); + }, x => _data.DistanceBasedLocationChanged += x, x => _data.DistanceBasedLocationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2765,9 +2463,7 @@ namespace Tizen.Location { void Handler(object sender, global::Tizen.Location.LocationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LocationChanged += x, x => _data.LocationChanged -= x); + }, x => _data.LocationChanged += x, x => _data.LocationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2775,9 +2471,7 @@ namespace Tizen.Location { void Handler(object sender, global::Tizen.Location.ServiceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServiceStateChanged += x, x => _data.ServiceStateChanged -= x); + }, x => _data.ServiceStateChanged += x, x => _data.ServiceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2785,9 +2479,7 @@ namespace Tizen.Location { void Handler(object sender, global::Tizen.Location.SettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SettingChanged += x, x => _data.SettingChanged -= x); + }, x => _data.SettingChanged += x, x => _data.SettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2795,9 +2487,7 @@ namespace Tizen.Location { void Handler(object sender, global::Tizen.Location.ZoneChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ZoneChanged += x, x => _data.ZoneChanged -= x); + }, x => _data.ZoneChanged += x, x => _data.ZoneChanged -= x); } } @@ -2836,9 +2526,7 @@ namespace Tizen.Location.Geofence { void Handler(object sender, global::Tizen.Location.Geofence.GeofenceResponseEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GeofenceEventChanged += x, x => _data.GeofenceEventChanged -= x); + }, x => _data.GeofenceEventChanged += x, x => _data.GeofenceEventChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2846,9 +2534,7 @@ namespace Tizen.Location.Geofence { void Handler(object sender, global::Tizen.Location.Geofence.ProximityStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ProximityChanged += x, x => _data.ProximityChanged -= x); + }, x => _data.ProximityChanged += x, x => _data.ProximityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2856,9 +2542,7 @@ namespace Tizen.Location.Geofence { void Handler(object sender, global::Tizen.Location.Geofence.GeofenceStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -2909,9 +2593,7 @@ namespace Tizen.Maps { void Handler(object sender, global::Tizen.Maps.MapGestureEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2919,9 +2601,7 @@ namespace Tizen.Maps { void Handler(object sender, global::Tizen.Maps.MapGestureEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DoubleClicked += x, x => _data.DoubleClicked -= x); + }, x => _data.DoubleClicked += x, x => _data.DoubleClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2929,9 +2609,7 @@ namespace Tizen.Maps { void Handler(object sender, global::Tizen.Maps.MapGestureEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LongPressed += x, x => _data.LongPressed -= x); + }, x => _data.LongPressed += x, x => _data.LongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2939,9 +2617,7 @@ namespace Tizen.Maps { void Handler(object sender, global::Tizen.Maps.MapGestureEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2949,9 +2625,7 @@ namespace Tizen.Maps { void Handler(object sender, global::Tizen.Maps.MapGestureEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TwoFingerClicked += x, x => _data.TwoFingerClicked -= x); + }, x => _data.TwoFingerClicked += x, x => _data.TwoFingerClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2959,9 +2633,7 @@ namespace Tizen.Maps { void Handler(object sender, global::Tizen.Maps.MapGestureEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TwoFingerRotated += x, x => _data.TwoFingerRotated -= x); + }, x => _data.TwoFingerRotated += x, x => _data.TwoFingerRotated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2969,9 +2641,7 @@ namespace Tizen.Maps { void Handler(object sender, global::Tizen.Maps.MapGestureEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TwoFingerZoomed += x, x => _data.TwoFingerZoomed -= x); + }, x => _data.TwoFingerZoomed += x, x => _data.TwoFingerZoomed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2979,9 +2649,7 @@ namespace Tizen.Maps { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewReady += x, x => _data.ViewReady -= x); + }, x => _data.ViewReady += x, x => _data.ViewReady -= x); } /// @@ -3006,9 +2674,7 @@ namespace Tizen.Maps { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -3033,9 +2699,7 @@ namespace Tizen.Maps { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -3060,9 +2724,7 @@ namespace Tizen.Maps { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } } @@ -3141,9 +2803,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioDataAvailableEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataAvailable += x, x => _data.DataAvailable -= x); + }, x => _data.DataAvailable += x, x => _data.DataAvailable -= x); } /// @@ -3168,9 +2828,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioIOStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -3195,9 +2853,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioPlaybackBufferAvailableEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferAvailable += x, x => _data.BufferAvailable -= x); + }, x => _data.BufferAvailable += x, x => _data.BufferAvailable -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3205,9 +2861,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioIOStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -3232,9 +2886,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioStreamPolicyFocusStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusStateChanged += x, x => _data.FocusStateChanged -= x); + }, x => _data.FocusStateChanged += x, x => _data.FocusStateChanged -= x); } /// @@ -3259,9 +2911,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.VolumeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } /// @@ -3286,9 +2936,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CaptureCompleted += x, x => _data.CaptureCompleted -= x); + }, x => _data.CaptureCompleted += x, x => _data.CaptureCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3296,9 +2944,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.CameraCapturingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Capturing += x, x => _data.Capturing -= x); + }, x => _data.Capturing += x, x => _data.Capturing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3306,9 +2952,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.CameraErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3316,9 +2960,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.FaceDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FaceDetected += x, x => _data.FaceDetected -= x); + }, x => _data.FaceDetected += x, x => _data.FaceDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3326,9 +2968,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.CameraFocusStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusStateChanged += x, x => _data.FocusStateChanged -= x); + }, x => _data.FocusStateChanged += x, x => _data.FocusStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3336,9 +2976,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.HdrCaptureProgressEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.HdrCaptureProgress += x, x => _data.HdrCaptureProgress -= x); + }, x => _data.HdrCaptureProgress += x, x => _data.HdrCaptureProgress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3346,9 +2984,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.CameraInterruptedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Interrupted += x, x => _data.Interrupted -= x); + }, x => _data.Interrupted += x, x => _data.Interrupted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3356,9 +2992,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.CameraInterruptStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InterruptStarted += x, x => _data.InterruptStarted -= x); + }, x => _data.InterruptStarted += x, x => _data.InterruptStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3366,9 +3000,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.MediaPacketPreviewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaPacketPreview += x, x => _data.MediaPacketPreview -= x); + }, x => _data.MediaPacketPreview += x, x => _data.MediaPacketPreview -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3376,9 +3008,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.PreviewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Preview += x, x => _data.Preview -= x); + }, x => _data.Preview += x, x => _data.Preview -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3386,9 +3016,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.CameraStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -3413,9 +3041,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.MediaStreamBufferStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferStatusChanged += x, x => _data.BufferStatusChanged -= x); + }, x => _data.BufferStatusChanged += x, x => _data.BufferStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3423,9 +3049,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.MediaStreamSeekingOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SeekingOccurred += x, x => _data.SeekingOccurred -= x); + }, x => _data.SeekingOccurred += x, x => _data.SeekingOccurred -= x); } /// @@ -3450,9 +3074,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.BufferingProgressChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3460,9 +3082,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.PlayerErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3470,9 +3090,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); + }, x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3480,9 +3098,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.PlaybackInterruptedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackInterrupted += x, x => _data.PlaybackInterrupted -= x); + }, x => _data.PlaybackInterrupted += x, x => _data.PlaybackInterrupted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3490,9 +3106,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.SubtitleUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SubtitleUpdated += x, x => _data.SubtitleUpdated -= x); + }, x => _data.SubtitleUpdated += x, x => _data.SubtitleUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3500,9 +3114,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.VideoFrameDecodedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VideoFrameDecoded += x, x => _data.VideoFrameDecoded -= x); + }, x => _data.VideoFrameDecoded += x, x => _data.VideoFrameDecoded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3510,9 +3122,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.VideoStreamChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VideoStreamChanged += x, x => _data.VideoStreamChanged -= x); + }, x => _data.VideoStreamChanged += x, x => _data.VideoStreamChanged -= x); } /// @@ -3537,9 +3147,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RadioInterruptedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Interrupted += x, x => _data.Interrupted -= x); + }, x => _data.Interrupted += x, x => _data.Interrupted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3547,9 +3155,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScanCompleted += x, x => _data.ScanCompleted -= x); + }, x => _data.ScanCompleted += x, x => _data.ScanCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3557,9 +3163,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScanStopped += x, x => _data.ScanStopped -= x); + }, x => _data.ScanStopped += x, x => _data.ScanStopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3567,9 +3171,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.ScanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScanUpdated += x, x => _data.ScanUpdated -= x); + }, x => _data.ScanUpdated += x, x => _data.ScanUpdated -= x); } /// @@ -3594,9 +3196,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioStreamStoringEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AudioStreamStoring += x, x => _data.AudioStreamStoring -= x); + }, x => _data.AudioStreamStoring += x, x => _data.AudioStreamStoring -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3604,9 +3204,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecordingErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3614,9 +3212,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecorderInterruptedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Interrupted += x, x => _data.Interrupted -= x); + }, x => _data.Interrupted += x, x => _data.Interrupted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3624,9 +3220,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecorderInterruptingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Interrupting += x, x => _data.Interrupting -= x); + }, x => _data.Interrupting += x, x => _data.Interrupting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3634,9 +3228,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.MuxedStreamDeliveredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MuxedStreamDelivered += x, x => _data.MuxedStreamDelivered -= x); + }, x => _data.MuxedStreamDelivered += x, x => _data.MuxedStreamDelivered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3644,9 +3236,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecordingLimitReachedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RecordingLimitReached += x, x => _data.RecordingLimitReached -= x); + }, x => _data.RecordingLimitReached += x, x => _data.RecordingLimitReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3654,9 +3244,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecordingStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RecordingStatusChanged += x, x => _data.RecordingStatusChanged -= x); + }, x => _data.RecordingStatusChanged += x, x => _data.RecordingStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3664,9 +3252,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecorderStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -3691,9 +3277,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.StreamRecorderBufferConsumedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferConsumed += x, x => _data.BufferConsumed -= x); + }, x => _data.BufferConsumed += x, x => _data.BufferConsumed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3701,9 +3285,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.StreamRecorderErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3711,9 +3293,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecordingLimitReachedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RecordingLimitReached += x, x => _data.RecordingLimitReached -= x); + }, x => _data.RecordingLimitReached += x, x => _data.RecordingLimitReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3721,9 +3301,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecordingStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RecordingStatusChanged += x, x => _data.RecordingStatusChanged -= x); + }, x => _data.RecordingStatusChanged += x, x => _data.RecordingStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3731,9 +3309,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.StreamRecorderStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -3772,9 +3348,7 @@ namespace Tizen.Multimedia.MediaCodec { void Handler(object sender, global::Tizen.Multimedia.MediaCodec.BufferStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferStatusChanged += x, x => _data.BufferStatusChanged -= x); + }, x => _data.BufferStatusChanged += x, x => _data.BufferStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3782,9 +3356,7 @@ namespace Tizen.Multimedia.MediaCodec { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EosReached += x, x => _data.EosReached -= x); + }, x => _data.EosReached += x, x => _data.EosReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3792,9 +3364,7 @@ namespace Tizen.Multimedia.MediaCodec { void Handler(object sender, global::Tizen.Multimedia.MediaCodec.MediaCodecErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3802,9 +3372,7 @@ namespace Tizen.Multimedia.MediaCodec { void Handler(object sender, global::Tizen.Multimedia.MediaCodec.InputProcessedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InputProcessed += x, x => _data.InputProcessed -= x); + }, x => _data.InputProcessed += x, x => _data.InputProcessed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3812,9 +3380,7 @@ namespace Tizen.Multimedia.MediaCodec { void Handler(object sender, global::Tizen.Multimedia.MediaCodec.OutputAvailableEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OutputAvailable += x, x => _data.OutputAvailable -= x); + }, x => _data.OutputAvailable += x, x => _data.OutputAvailable -= x); } } @@ -3861,9 +3427,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.MetadataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MetadataUpdated += x, x => _data.MetadataUpdated -= x); + }, x => _data.MetadataUpdated += x, x => _data.MetadataUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3871,9 +3435,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.PlaybackStateUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStateUpdated += x, x => _data.PlaybackStateUpdated -= x); + }, x => _data.PlaybackStateUpdated += x, x => _data.PlaybackStateUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3881,9 +3443,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.RepeatModeUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RepeatModeUpdated += x, x => _data.RepeatModeUpdated -= x); + }, x => _data.RepeatModeUpdated += x, x => _data.RepeatModeUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3891,9 +3451,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServerStopped += x, x => _data.ServerStopped -= x); + }, x => _data.ServerStopped += x, x => _data.ServerStopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3901,9 +3459,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.ShuffleModeUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ShuffleModeUpdated += x, x => _data.ShuffleModeUpdated -= x); + }, x => _data.ShuffleModeUpdated += x, x => _data.ShuffleModeUpdated -= x); } /// @@ -3928,9 +3484,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.MediaControlServerStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServerStarted += x, x => _data.ServerStarted -= x); + }, x => _data.ServerStarted += x, x => _data.ServerStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3938,9 +3492,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.MediaControlServerStoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServerStopped += x, x => _data.ServerStopped -= x); + }, x => _data.ServerStopped += x, x => _data.ServerStopped -= x); } /// @@ -3965,9 +3517,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.ScreenMirroringErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3975,9 +3525,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.ScreenMirroringStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -4024,9 +3572,7 @@ namespace Tizen.Multimedia.Vision { void Handler(object sender, global::Tizen.Multimedia.Vision.MovementDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Detected += x, x => _data.Detected -= x); + }, x => _data.Detected += x, x => _data.Detected -= x); } /// @@ -4051,9 +3597,7 @@ namespace Tizen.Multimedia.Vision { void Handler(object sender, global::Tizen.Multimedia.Vision.PersonAppearanceDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Detected += x, x => _data.Detected -= x); + }, x => _data.Detected += x, x => _data.Detected -= x); } /// @@ -4078,9 +3622,7 @@ namespace Tizen.Multimedia.Vision { void Handler(object sender, global::Tizen.Multimedia.Vision.PersonRecognizedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Recognized += x, x => _data.Recognized -= x); + }, x => _data.Recognized += x, x => _data.Recognized -= x); } } @@ -4167,9 +3709,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.AudioConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AudioConnectionStateChanged += x, x => _data.AudioConnectionStateChanged -= x); + }, x => _data.AudioConnectionStateChanged += x, x => _data.AudioConnectionStateChanged -= x); } /// @@ -4194,9 +3734,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.EqualizerStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EqualizerStateChanged += x, x => _data.EqualizerStateChanged -= x); + }, x => _data.EqualizerStateChanged += x, x => _data.EqualizerStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4204,9 +3742,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.RepeatModeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RepeatModeChanged += x, x => _data.RepeatModeChanged -= x); + }, x => _data.RepeatModeChanged += x, x => _data.RepeatModeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4214,9 +3750,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.ScanModeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScanModeChanged += x, x => _data.ScanModeChanged -= x); + }, x => _data.ScanModeChanged += x, x => _data.ScanModeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4224,9 +3758,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.ShuffleModeChangedeventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ShuffleModeChanged += x, x => _data.ShuffleModeChanged -= x); + }, x => _data.ShuffleModeChanged += x, x => _data.ShuffleModeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4234,9 +3766,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.TargetConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TargetConnectionStateChanged += x, x => _data.TargetConnectionStateChanged -= x); + }, x => _data.TargetConnectionStateChanged += x, x => _data.TargetConnectionStateChanged -= x); } /// @@ -4261,9 +3791,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.AuthorizationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AuthorizationChanged += x, x => _data.AuthorizationChanged -= x); + }, x => _data.AuthorizationChanged += x, x => _data.AuthorizationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4271,9 +3799,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.BondCreatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BondCreated += x, x => _data.BondCreated -= x); + }, x => _data.BondCreated += x, x => _data.BondCreated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4281,9 +3807,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.BondDestroyedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BondDestroyed += x, x => _data.BondDestroyed -= x); + }, x => _data.BondDestroyed += x, x => _data.BondDestroyed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4291,9 +3815,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.DeviceConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConnectionStateChanged += x, x => _data.ConnectionStateChanged -= x); + }, x => _data.ConnectionStateChanged += x, x => _data.ConnectionStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4301,9 +3823,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.ServiceSearchedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServiceSearched += x, x => _data.ServiceSearched -= x); + }, x => _data.ServiceSearched += x, x => _data.ServiceSearched -= x); } /// @@ -4328,9 +3848,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.ReadRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4338,9 +3856,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.WriteRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); } /// @@ -4365,9 +3881,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.NotificationStateChangedEventArg e) => eventHandler(e); return Handler; - } - - , x => _data.NotificationStateChanged += x, x => _data.NotificationStateChanged -= x); + }, x => _data.NotificationStateChanged += x, x => _data.NotificationStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4375,9 +3889,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -4402,9 +3914,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.NotificationSentEventArg e) => eventHandler(e); return Handler; - } - - , x => _data.NotificationSent += x, x => _data.NotificationSent -= x); + }, x => _data.NotificationSent += x, x => _data.NotificationSent -= x); } /// @@ -4429,9 +3939,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.HidConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.HidConnectionStateChanged += x, x => _data.HidConnectionStateChanged -= x); + }, x => _data.HidConnectionStateChanged += x, x => _data.HidConnectionStateChanged -= x); } /// @@ -4456,9 +3964,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.AdvertisingStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AdvertisingStateChanged += x, x => _data.AdvertisingStateChanged -= x); + }, x => _data.AdvertisingStateChanged += x, x => _data.AdvertisingStateChanged -= x); } /// @@ -4483,9 +3989,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.GattConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GattConnectionStateChanged += x, x => _data.GattConnectionStateChanged -= x); + }, x => _data.GattConnectionStateChanged += x, x => _data.GattConnectionStateChanged -= x); } /// @@ -4510,9 +4014,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.PushFinishedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushFinished += x, x => _data.PushFinished -= x); + }, x => _data.PushFinished += x, x => _data.PushFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4520,9 +4022,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.PushProgressEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushProgress += x, x => _data.PushProgress -= x); + }, x => _data.PushProgress += x, x => _data.PushProgress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4530,9 +4030,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.PushRespondedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushResponded += x, x => _data.PushResponded -= x); + }, x => _data.PushResponded += x, x => _data.PushResponded -= x); } /// @@ -4557,9 +4055,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.ConnectionRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); + }, x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4567,9 +4063,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.TransferFinishedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TransferFinished += x, x => _data.TransferFinished -= x); + }, x => _data.TransferFinished += x, x => _data.TransferFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4577,9 +4071,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.TransferProgressEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TransferProgress += x, x => _data.TransferProgress -= x); + }, x => _data.TransferProgress += x, x => _data.TransferProgress -= x); } /// @@ -4604,9 +4096,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.AcceptStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AcceptStateChanged += x, x => _data.AcceptStateChanged -= x); + }, x => _data.AcceptStateChanged += x, x => _data.AcceptStateChanged -= x); } /// @@ -4631,9 +4121,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.SocketConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConnectionStateChanged += x, x => _data.ConnectionStateChanged -= x); + }, x => _data.ConnectionStateChanged += x, x => _data.ConnectionStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4641,9 +4129,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.SocketDataReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); } } @@ -4682,9 +4168,7 @@ namespace Tizen.Network.Connection { void Handler(object sender, global::Tizen.Network.Connection.ProfileStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ProfileStateChanged += x, x => _data.ProfileStateChanged -= x); + }, x => _data.ProfileStateChanged += x, x => _data.ProfileStateChanged -= x); } } @@ -4723,9 +4207,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.CacheUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CacheUpdated += x, x => _data.CacheUpdated -= x); + }, x => _data.CacheUpdated += x, x => _data.CacheUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4733,9 +4215,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.ObserverNotifiedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ObserverNotified += x, x => _data.ObserverNotified -= x); + }, x => _data.ObserverNotified += x, x => _data.ObserverNotified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4743,9 +4223,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -4796,9 +4274,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.SecureElementTranscationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EseSecureElementTransactionEvent += x, x => _data.EseSecureElementTransactionEvent -= x); + }, x => _data.EseSecureElementTransactionEvent += x, x => _data.EseSecureElementTransactionEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4806,9 +4282,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.HostCardEmulationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.HostCardEmulationEvent += x, x => _data.HostCardEmulationEvent -= x); + }, x => _data.HostCardEmulationEvent += x, x => _data.HostCardEmulationEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4816,9 +4290,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.SecureElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SecureElementEvent += x, x => _data.SecureElementEvent -= x); + }, x => _data.SecureElementEvent += x, x => _data.SecureElementEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4826,9 +4298,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.SecureElementTranscationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UiccSecureElementTransactionEvent += x, x => _data.UiccSecureElementTransactionEvent -= x); + }, x => _data.UiccSecureElementTransactionEvent += x, x => _data.UiccSecureElementTransactionEvent -= x); } /// @@ -4853,9 +4323,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.P2pDataReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.P2pDataReceived += x, x => _data.P2pDataReceived -= x); + }, x => _data.P2pDataReceived += x, x => _data.P2pDataReceived -= x); } /// @@ -4880,9 +4348,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.P2pTargetDiscoveredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.P2pTargetDiscovered += x, x => _data.P2pTargetDiscovered -= x); + }, x => _data.P2pTargetDiscovered += x, x => _data.P2pTargetDiscovered -= x); } /// @@ -4907,9 +4373,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.TagDiscoveredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TagDiscovered += x, x => _data.TagDiscovered -= x); + }, x => _data.TagDiscovered += x, x => _data.TagDiscovered -= x); } } @@ -4952,9 +4416,7 @@ namespace Tizen.Network.Nsd { void Handler(object sender, global::Tizen.Network.Nsd.DnssdServiceFoundEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServiceFound += x, x => _data.ServiceFound -= x); + }, x => _data.ServiceFound += x, x => _data.ServiceFound -= x); } /// @@ -4979,9 +4441,7 @@ namespace Tizen.Network.Nsd { void Handler(object sender, global::Tizen.Network.Nsd.SsdpServiceFoundEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServiceFound += x, x => _data.ServiceFound -= x); + }, x => _data.ServiceFound += x, x => _data.ServiceFound -= x); } } @@ -5020,9 +4480,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.ConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConnectionStateChanged += x, x => _data.ConnectionStateChanged -= x); + }, x => _data.ConnectionStateChanged += x, x => _data.ConnectionStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5030,9 +4488,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.IpAddressAssignedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IpAddressAssigned += x, x => _data.IpAddressAssigned -= x); + }, x => _data.IpAddressAssigned += x, x => _data.IpAddressAssigned -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5040,9 +4496,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.ServiceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ServiceStateChanged += x, x => _data.ServiceStateChanged -= x); + }, x => _data.ServiceStateChanged += x, x => _data.ServiceStateChanged -= x); } } @@ -5117,9 +4571,7 @@ namespace Tizen.NUI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Finished += x, x => _data.Finished -= x); + }, x => _data.Finished += x, x => _data.Finished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5127,9 +4579,7 @@ namespace Tizen.NUI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ProgressReached += x, x => _data.ProgressReached -= x); + }, x => _data.ProgressReached += x, x => _data.ProgressReached -= x); } /// @@ -5154,9 +4604,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.FocusManager.FocusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChanged += x, x => _data.FocusChanged -= x); + }, x => _data.FocusChanged += x, x => _data.FocusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5164,9 +4612,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.FocusManager.FocusedViewActivatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusedViewActivated += x, x => _data.FocusedViewActivated -= x); + }, x => _data.FocusedViewActivated += x, x => _data.FocusedViewActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5175,9 +4621,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.FocusManager.FocusedViewEnterKeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusedViewEnterKeyPressed += x, x => _data.FocusedViewEnterKeyPressed -= x); + }, x => _data.FocusedViewEnterKeyPressed += x, x => _data.FocusedViewEnterKeyPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5185,9 +4629,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.FocusManager.FocusGroupChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusGroupChanged += x, x => _data.FocusGroupChanged -= x); + }, x => _data.FocusGroupChanged += x, x => _data.FocusGroupChanged -= x); } /// @@ -5212,9 +4654,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.ImfManager.ActivatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5222,9 +4662,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.ImfManager.KeyboardTypeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyboardTypeChanged += x, x => _data.KeyboardTypeChanged -= x); + }, x => _data.KeyboardTypeChanged += x, x => _data.KeyboardTypeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5232,9 +4670,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.ImfManager.LanguageChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); + }, x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5242,9 +4678,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.ImfManager.ResizedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resized += x, x => _data.Resized -= x); + }, x => _data.Resized += x, x => _data.Resized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5252,9 +4686,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.ImfManager.StatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -5279,9 +4711,7 @@ namespace Tizen.NUI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paused += x, x => _data.Paused -= x); + }, x => _data.Paused += x, x => _data.Paused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5289,9 +4719,7 @@ namespace Tizen.NUI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resumed += x, x => _data.Resumed -= x); + }, x => _data.Resumed += x, x => _data.Resumed -= x); } /// @@ -5316,9 +4744,7 @@ namespace Tizen.NUI { void Handler(object source, global::Tizen.NUI.PropertyNotification.NotifyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Notified += x, x => _data.Notified -= x); + }, x => _data.Notified += x, x => _data.Notified -= x); } /// @@ -5343,9 +4769,7 @@ namespace Tizen.NUI { void Handler(object source, global::Tizen.NUI.ScrollView.SnapStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SnapStarted += x, x => _data.SnapStarted -= x); + }, x => _data.SnapStarted += x, x => _data.SnapStarted -= x); } /// @@ -5370,9 +4794,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.StyleManager.StyleChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StyleChanged += x, x => _data.StyleChanged -= x); + }, x => _data.StyleChanged += x, x => _data.StyleChanged -= x); } /// @@ -5397,9 +4819,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.TTSPlayer.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -5424,9 +4844,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.WidgetView.WidgetViewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WidgetAdded += x, x => _data.WidgetAdded -= x); + }, x => _data.WidgetAdded += x, x => _data.WidgetAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5434,9 +4852,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.WidgetView.WidgetViewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WidgetContentUpdated += x, x => _data.WidgetContentUpdated -= x); + }, x => _data.WidgetContentUpdated += x, x => _data.WidgetContentUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5444,9 +4860,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.WidgetView.WidgetViewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WidgetCreationAborted += x, x => _data.WidgetCreationAborted -= x); + }, x => _data.WidgetCreationAborted += x, x => _data.WidgetCreationAborted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5454,9 +4868,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.WidgetView.WidgetViewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WidgetDeleted += x, x => _data.WidgetDeleted -= x); + }, x => _data.WidgetDeleted += x, x => _data.WidgetDeleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5464,9 +4876,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.WidgetView.WidgetViewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WidgetFaulted += x, x => _data.WidgetFaulted -= x); + }, x => _data.WidgetFaulted += x, x => _data.WidgetFaulted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5474,9 +4884,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.WidgetView.WidgetViewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WidgetUpdatePeriodChanged += x, x => _data.WidgetUpdatePeriodChanged -= x); + }, x => _data.WidgetUpdatePeriodChanged += x, x => _data.WidgetUpdatePeriodChanged -= x); } /// @@ -5501,9 +4909,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.Window.FocusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChanged += x, x => _data.FocusChanged -= x); + }, x => _data.FocusChanged += x, x => _data.FocusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5511,9 +4917,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.Window.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyEvent += x, x => _data.KeyEvent -= x); + }, x => _data.KeyEvent += x, x => _data.KeyEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5521,9 +4925,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.Window.ResizedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resized += x, x => _data.Resized -= x); + }, x => _data.Resized += x, x => _data.Resized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5531,9 +4933,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.Window.TouchEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); + }, x => _data.TouchEvent += x, x => _data.TouchEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5541,9 +4941,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.Window.WheelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WheelEvent += x, x => _data.WheelEvent -= x); + }, x => _data.WheelEvent += x, x => _data.WheelEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5552,9 +4950,7 @@ namespace Tizen.NUI { void Handler(object sender, global::Tizen.NUI.Window.WindowFocusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WindowFocusChanged += x, x => _data.WindowFocusChanged -= x); + }, x => _data.WindowFocusChanged += x, x => _data.WindowFocusChanged -= x); } } @@ -5613,9 +5009,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.ImageView.ResourceReadyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourceReady += x, x => _data.ResourceReady -= x); + }, x => _data.ResourceReady += x, x => _data.ResourceReady -= x); } /// @@ -5640,9 +5034,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object source, global::Tizen.NUI.BaseComponents.Scrollable.CompletedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollCompleted += x, x => _data.ScrollCompleted -= x); + }, x => _data.ScrollCompleted += x, x => _data.ScrollCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5650,9 +5042,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object source, global::Tizen.NUI.BaseComponents.Scrollable.StartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollStarted += x, x => _data.ScrollStarted -= x); + }, x => _data.ScrollStarted += x, x => _data.ScrollStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5660,9 +5050,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object source, global::Tizen.NUI.BaseComponents.Scrollable.UpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollUpdated += x, x => _data.ScrollUpdated -= x); + }, x => _data.ScrollUpdated += x, x => _data.ScrollUpdated -= x); } /// @@ -5687,9 +5075,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.TextEditor.ScrollStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollStateChanged += x, x => _data.ScrollStateChanged -= x); + }, x => _data.ScrollStateChanged += x, x => _data.ScrollStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5697,9 +5083,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.TextEditor.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -5724,9 +5108,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.TextField.MaxLengthReachedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MaxLengthReached += x, x => _data.MaxLengthReached -= x); + }, x => _data.MaxLengthReached += x, x => _data.MaxLengthReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5734,9 +5116,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.TextField.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -5761,9 +5141,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.VideoView.FinishedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Finished += x, x => _data.Finished -= x); + }, x => _data.Finished += x, x => _data.Finished -= x); } /// @@ -5788,9 +5166,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AddedToWindow += x, x => _data.AddedToWindow -= x); + }, x => _data.AddedToWindow += x, x => _data.AddedToWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5798,9 +5174,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusGained += x, x => _data.FocusGained -= x); + }, x => _data.FocusGained += x, x => _data.FocusGained -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5808,9 +5182,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusLost += x, x => _data.FocusLost -= x); + }, x => _data.FocusLost += x, x => _data.FocusLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5818,9 +5190,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.View.LayoutDirectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutDirectionChanged += x, x => _data.LayoutDirectionChanged -= x); + }, x => _data.LayoutDirectionChanged += x, x => _data.LayoutDirectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5828,9 +5198,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Relayout += x, x => _data.Relayout -= x); + }, x => _data.Relayout += x, x => _data.Relayout -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5838,9 +5206,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovedFromWindow += x, x => _data.RemovedFromWindow -= x); + }, x => _data.RemovedFromWindow += x, x => _data.RemovedFromWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5848,9 +5214,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResourcesLoaded += x, x => _data.ResourcesLoaded -= x); + }, x => _data.ResourcesLoaded += x, x => _data.ResourcesLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5858,9 +5222,7 @@ namespace Tizen.NUI.BaseComponents { void Handler(object sender, global::Tizen.NUI.BaseComponents.View.VisibilityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } } @@ -5907,9 +5269,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.Popup.HiddenEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Hidden += x, x => _data.Hidden -= x); + }, x => _data.Hidden += x, x => _data.Hidden -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5917,9 +5277,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.Popup.HidingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Hiding += x, x => _data.Hiding -= x); + }, x => _data.Hiding += x, x => _data.Hiding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5927,9 +5285,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.Popup.ShowingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Showing += x, x => _data.Showing -= x); + }, x => _data.Showing += x, x => _data.Showing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5937,9 +5293,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.Popup.ShownEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Shown += x, x => _data.Shown -= x); + }, x => _data.Shown += x, x => _data.Shown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5947,9 +5301,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.Popup.TouchedOutsideEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TouchedOutside += x, x => _data.TouchedOutside -= x); + }, x => _data.TouchedOutside += x, x => _data.TouchedOutside -= x); } /// @@ -5974,9 +5326,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.ProgressBar.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -6001,9 +5351,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.ScrollBar.PanFinishedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanFinished += x, x => _data.PanFinished -= x); + }, x => _data.PanFinished += x, x => _data.PanFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6011,9 +5359,7 @@ namespace Tizen.NUI.UIComponents { void Handler(object sender, global::Tizen.NUI.UIComponents.ScrollBar.ScrollIntervalEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollInterval += x, x => _data.ScrollInterval -= x); + }, x => _data.ScrollInterval += x, x => _data.ScrollInterval -= x); } } @@ -6056,9 +5402,7 @@ namespace Tizen.Pims.Contacts { void Handler(object sender, global::Tizen.Pims.Contacts.DBStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DBStatusChanged += x, x => _data.DBStatusChanged -= x); + }, x => _data.DBStatusChanged += x, x => _data.DBStatusChanged -= x); } /// @@ -6083,9 +5427,7 @@ namespace Tizen.Pims.Contacts { void Handler(object sender, global::Tizen.Pims.Contacts.NameDisplayOrderChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NameDisplayOrderChanged += x, x => _data.NameDisplayOrderChanged -= x); + }, x => _data.NameDisplayOrderChanged += x, x => _data.NameDisplayOrderChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6093,9 +5435,7 @@ namespace Tizen.Pims.Contacts { void Handler(object sender, global::Tizen.Pims.Contacts.NameSortingOrderChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NameSortingOrderChanged += x, x => _data.NameSortingOrderChanged -= x); + }, x => _data.NameSortingOrderChanged += x, x => _data.NameSortingOrderChanged -= x); } } @@ -6134,9 +5474,7 @@ namespace Tizen.Security { void Handler(object sender, global::Tizen.Security.RequestResponseEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResponseFetched += x, x => _data.ResponseFetched -= x); + }, x => _data.ResponseFetched += x, x => _data.ResponseFetched -= x); } } @@ -6279,9 +5617,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.AccelerometerDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6306,9 +5642,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.FaceDownGestureDetectorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6333,9 +5667,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SensorAccuracyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); + }, x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6343,9 +5675,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.GravitySensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6370,9 +5700,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.GyroscopeDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6397,9 +5725,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.GyroscopeRotationVectorSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6424,9 +5750,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.HeartRateMonitorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6451,9 +5775,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.HumiditySensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6478,9 +5800,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.InVehicleActivityDetectorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6505,9 +5825,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.LightSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6532,9 +5850,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SensorAccuracyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); + }, x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6542,9 +5858,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.LinearAccelerationSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6569,9 +5883,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SensorAccuracyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); + }, x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6579,9 +5891,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.MagnetometerDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6606,9 +5916,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SensorAccuracyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); + }, x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6616,9 +5924,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.MagnetometerRotationVectorSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6643,9 +5949,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SensorAccuracyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); + }, x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6653,9 +5957,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.OrientationSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6680,9 +5982,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.PedometerDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6707,9 +6007,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.PickUpGestureDetectorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6734,9 +6032,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.PressureSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6761,9 +6057,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.ProximitySensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6788,9 +6082,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SensorAccuracyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); + }, x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6798,9 +6090,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.RotationVectorSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6825,9 +6115,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.RunningActivityDetectorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6852,9 +6140,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SleepMonitorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6879,9 +6165,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.StationaryActivityDetectorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6906,9 +6190,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.TemperatureSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6933,9 +6215,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.UltravioletSensorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6960,9 +6240,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.UncalibratedGyroscopeDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -6987,9 +6265,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.SensorAccuracyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); + }, x => _data.AccuracyChanged += x, x => _data.AccuracyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6997,9 +6273,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.UncalibratedMagnetometerDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -7024,9 +6298,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.WalkingActivityDetectorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } /// @@ -7051,9 +6323,7 @@ namespace Tizen.Sensor { void Handler(object sender, global::Tizen.Sensor.WristUpGestureDetectorDataUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DataUpdated += x, x => _data.DataUpdated -= x); + }, x => _data.DataUpdated += x, x => _data.DataUpdated -= x); } } @@ -7092,9 +6362,7 @@ namespace Tizen.System { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StorageStateChanged += x, x => _data.StorageStateChanged -= x); + }, x => _data.StorageStateChanged += x, x => _data.StorageStateChanged -= x); } } @@ -7133,9 +6401,7 @@ namespace Tizen.System.Usb { void Handler(object sender, global::Tizen.System.Usb.HotPluggedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DeviceHotPlugged += x, x => _data.DeviceHotPlugged -= x); + }, x => _data.DeviceHotPlugged += x, x => _data.DeviceHotPlugged -= x); } } @@ -7174,9 +6440,7 @@ namespace Tizen.Telephony { void Handler(object sender, global::Tizen.Telephony.ChangeNotificationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChangeNotification += x, x => _data.ChangeNotification -= x); + }, x => _data.ChangeNotification += x, x => _data.ChangeNotification -= x); } } @@ -7215,9 +6479,7 @@ namespace Tizen.Uix.Stt { void Handler(object sender, global::Tizen.Uix.Stt.DefaultLanguageChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DefaultLanguageChanged += x, x => _data.DefaultLanguageChanged -= x); + }, x => _data.DefaultLanguageChanged += x, x => _data.DefaultLanguageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7225,9 +6487,7 @@ namespace Tizen.Uix.Stt { void Handler(object sender, global::Tizen.Uix.Stt.EngineChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EngineChanged += x, x => _data.EngineChanged -= x); + }, x => _data.EngineChanged += x, x => _data.EngineChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7235,9 +6495,7 @@ namespace Tizen.Uix.Stt { void Handler(object sender, global::Tizen.Uix.Stt.ErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7245,9 +6503,7 @@ namespace Tizen.Uix.Stt { void Handler(object sender, global::Tizen.Uix.Stt.RecognitionResultEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RecognitionResult += x, x => _data.RecognitionResult -= x); + }, x => _data.RecognitionResult += x, x => _data.RecognitionResult -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7255,9 +6511,7 @@ namespace Tizen.Uix.Stt { void Handler(object sender, global::Tizen.Uix.Stt.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -7296,9 +6550,7 @@ namespace Tizen.Uix.Tts { void Handler(object sender, global::Tizen.Uix.Tts.DefaultVoiceChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DefaultVoiceChanged += x, x => _data.DefaultVoiceChanged -= x); + }, x => _data.DefaultVoiceChanged += x, x => _data.DefaultVoiceChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7306,9 +6558,7 @@ namespace Tizen.Uix.Tts { void Handler(object sender, global::Tizen.Uix.Tts.EngineChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EngineChanged += x, x => _data.EngineChanged -= x); + }, x => _data.EngineChanged += x, x => _data.EngineChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7316,9 +6566,7 @@ namespace Tizen.Uix.Tts { void Handler(object sender, global::Tizen.Uix.Tts.ErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7326,9 +6574,7 @@ namespace Tizen.Uix.Tts { void Handler(object sender, global::Tizen.Uix.Tts.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7336,9 +6582,7 @@ namespace Tizen.Uix.Tts { void Handler(object sender, global::Tizen.Uix.Tts.UtteranceEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UtteranceCompleted += x, x => _data.UtteranceCompleted -= x); + }, x => _data.UtteranceCompleted += x, x => _data.UtteranceCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7346,9 +6590,7 @@ namespace Tizen.Uix.Tts { void Handler(object sender, global::Tizen.Uix.Tts.UtteranceEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UtteranceStarted += x, x => _data.UtteranceStarted -= x); + }, x => _data.UtteranceStarted += x, x => _data.UtteranceStarted -= x); } } @@ -7387,9 +6629,7 @@ namespace Tizen.WebView { void Handler(object sender, global::Tizen.WebView.SmartCallbackLoadErrorArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadError += x, x => _data.LoadError -= x); + }, x => _data.LoadError += x, x => _data.LoadError -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7397,9 +6637,7 @@ namespace Tizen.WebView { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadFinished += x, x => _data.LoadFinished -= x); + }, x => _data.LoadFinished += x, x => _data.LoadFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7407,9 +6645,7 @@ namespace Tizen.WebView { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadStarted += x, x => _data.LoadStarted -= x); + }, x => _data.LoadStarted += x, x => _data.LoadStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7417,9 +6653,7 @@ namespace Tizen.WebView { void Handler(object sender, global::Tizen.WebView.SmartCallbackArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TitleChanged += x, x => _data.TitleChanged -= x); + }, x => _data.TitleChanged += x, x => _data.TitleChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7427,9 +6661,7 @@ namespace Tizen.WebView { void Handler(object sender, global::Tizen.WebView.SmartCallbackArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UrlChanged += x, x => _data.UrlChanged -= x); + }, x => _data.UrlChanged += x, x => _data.UrlChanged -= x); } } @@ -7447,9 +6679,7 @@ namespace ElmSharp.Wearable { void Handler(global::ElmSharp.Wearable.RotaryEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::ElmSharp.Wearable.RotaryEventManager.Rotated += x, x => global::ElmSharp.Wearable.RotaryEventManager.Rotated -= x); + }, x => global::ElmSharp.Wearable.RotaryEventManager.Rotated += x, x => global::ElmSharp.Wearable.RotaryEventManager.Rotated -= x); } } @@ -7467,9 +6697,7 @@ namespace Tizen.Account.AccountManager { void Handler(object sender, global::Tizen.Account.AccountManager.AccountSubscriberEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Account.AccountManager.AccountService.AccountUpdated += x, x => global::Tizen.Account.AccountManager.AccountService.AccountUpdated -= x); + }, x => global::Tizen.Account.AccountManager.AccountService.AccountUpdated += x, x => global::Tizen.Account.AccountManager.AccountService.AccountUpdated -= x); } } @@ -7487,9 +6715,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.ApplicationDisabledEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.ApplicationManager.ApplicationDisabled += x, x => global::Tizen.Applications.ApplicationManager.ApplicationDisabled -= x); + }, x => global::Tizen.Applications.ApplicationManager.ApplicationDisabled += x, x => global::Tizen.Applications.ApplicationManager.ApplicationDisabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7497,9 +6723,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.ApplicationEnabledEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.ApplicationManager.ApplicationEnabled += x, x => global::Tizen.Applications.ApplicationManager.ApplicationEnabled -= x); + }, x => global::Tizen.Applications.ApplicationManager.ApplicationEnabled += x, x => global::Tizen.Applications.ApplicationManager.ApplicationEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7507,9 +6731,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.ApplicationLaunchedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.ApplicationManager.ApplicationLaunched += x, x => global::Tizen.Applications.ApplicationManager.ApplicationLaunched -= x); + }, x => global::Tizen.Applications.ApplicationManager.ApplicationLaunched += x, x => global::Tizen.Applications.ApplicationManager.ApplicationLaunched -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7517,9 +6739,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.ApplicationTerminatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.ApplicationManager.ApplicationTerminated += x, x => global::Tizen.Applications.ApplicationManager.ApplicationTerminated -= x); + }, x => global::Tizen.Applications.ApplicationManager.ApplicationTerminated += x, x => global::Tizen.Applications.ApplicationManager.ApplicationTerminated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7527,9 +6747,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.BadgeEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.BadgeControl.Changed += x, x => global::Tizen.Applications.BadgeControl.Changed -= x); + }, x => global::Tizen.Applications.BadgeControl.Changed += x, x => global::Tizen.Applications.BadgeControl.Changed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7537,9 +6755,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.PackageManagerEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.PackageManager.ClearDataProgressChanged += x, x => global::Tizen.Applications.PackageManager.ClearDataProgressChanged -= x); + }, x => global::Tizen.Applications.PackageManager.ClearDataProgressChanged += x, x => global::Tizen.Applications.PackageManager.ClearDataProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7547,9 +6763,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.PackageManagerEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.PackageManager.InstallProgressChanged += x, x => global::Tizen.Applications.PackageManager.InstallProgressChanged -= x); + }, x => global::Tizen.Applications.PackageManager.InstallProgressChanged += x, x => global::Tizen.Applications.PackageManager.InstallProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7557,9 +6771,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.PackageManagerEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.PackageManager.MoveProgressChanged += x, x => global::Tizen.Applications.PackageManager.MoveProgressChanged -= x); + }, x => global::Tizen.Applications.PackageManager.MoveProgressChanged += x, x => global::Tizen.Applications.PackageManager.MoveProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7567,9 +6779,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.PackageManagerEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.PackageManager.UninstallProgressChanged += x, x => global::Tizen.Applications.PackageManager.UninstallProgressChanged -= x); + }, x => global::Tizen.Applications.PackageManager.UninstallProgressChanged += x, x => global::Tizen.Applications.PackageManager.UninstallProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7577,9 +6787,7 @@ namespace Tizen.Applications { void Handler(object sender, global::Tizen.Applications.PackageManagerEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.PackageManager.UpdateProgressChanged += x, x => global::Tizen.Applications.PackageManager.UpdateProgressChanged -= x); + }, x => global::Tizen.Applications.PackageManager.UpdateProgressChanged += x, x => global::Tizen.Applications.PackageManager.UpdateProgressChanged -= x); } } @@ -7597,9 +6805,7 @@ namespace Tizen.Applications.NotificationEventListener { void Handler(object sender, global::Tizen.Applications.NotificationEventListener.NotificationEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Added += x, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Added -= x); + }, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Added += x, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7607,9 +6813,7 @@ namespace Tizen.Applications.NotificationEventListener { void Handler(object sender, global::Tizen.Applications.NotificationEventListener.NotificationDeleteEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Deleted += x, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Deleted -= x); + }, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Deleted += x, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Deleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7617,9 +6821,7 @@ namespace Tizen.Applications.NotificationEventListener { void Handler(object sender, global::Tizen.Applications.NotificationEventListener.NotificationEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Updated += x, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Updated -= x); + }, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Updated += x, x => global::Tizen.Applications.NotificationEventListener.NotificationListenerManager.Updated -= x); } } @@ -7637,9 +6839,7 @@ namespace Tizen.Content.MediaContent { void Handler(object sender, global::Tizen.Content.MediaContent.FolderUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Content.MediaContent.MediaDatabase.FolderUpdated += x, x => global::Tizen.Content.MediaContent.MediaDatabase.FolderUpdated -= x); + }, x => global::Tizen.Content.MediaContent.MediaDatabase.FolderUpdated += x, x => global::Tizen.Content.MediaContent.MediaDatabase.FolderUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7647,9 +6847,7 @@ namespace Tizen.Content.MediaContent { void Handler(object sender, global::Tizen.Content.MediaContent.MediaInfoUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Content.MediaContent.MediaDatabase.MediaInfoUpdated += x, x => global::Tizen.Content.MediaContent.MediaDatabase.MediaInfoUpdated -= x); + }, x => global::Tizen.Content.MediaContent.MediaDatabase.MediaInfoUpdated += x, x => global::Tizen.Content.MediaContent.MediaDatabase.MediaInfoUpdated -= x); } } @@ -7667,9 +6865,7 @@ namespace Tizen.Messaging.Messages { void Handler(object sender, global::Tizen.Messaging.Messages.MessageReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Messaging.Messages.MessagesManager.MessageReceived += x, x => global::Tizen.Messaging.Messages.MessagesManager.MessageReceived -= x); + }, x => global::Tizen.Messaging.Messages.MessagesManager.MessageReceived += x, x => global::Tizen.Messaging.Messages.MessagesManager.MessageReceived -= x); } } @@ -7687,9 +6883,7 @@ namespace Tizen.Messaging.Push { void Handler(object sender, global::Tizen.Messaging.Push.PushMessageEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Messaging.Push.PushClient.NotificationReceived += x, x => global::Tizen.Messaging.Push.PushClient.NotificationReceived -= x); + }, x => global::Tizen.Messaging.Push.PushClient.NotificationReceived += x, x => global::Tizen.Messaging.Push.PushClient.NotificationReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7697,9 +6891,7 @@ namespace Tizen.Messaging.Push { void Handler(object sender, global::Tizen.Messaging.Push.PushConnectionStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Messaging.Push.PushClient.StateChanged += x, x => global::Tizen.Messaging.Push.PushClient.StateChanged -= x); + }, x => global::Tizen.Messaging.Push.PushClient.StateChanged += x, x => global::Tizen.Messaging.Push.PushClient.StateChanged -= x); } } @@ -7717,9 +6909,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioDeviceConnectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Multimedia.AudioManager.DeviceConnectionChanged += x, x => global::Tizen.Multimedia.AudioManager.DeviceConnectionChanged -= x); + }, x => global::Tizen.Multimedia.AudioManager.DeviceConnectionChanged += x, x => global::Tizen.Multimedia.AudioManager.DeviceConnectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7727,9 +6917,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.AudioDeviceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Multimedia.AudioManager.DeviceStateChanged += x, x => global::Tizen.Multimedia.AudioManager.DeviceStateChanged -= x); + }, x => global::Tizen.Multimedia.AudioManager.DeviceStateChanged += x, x => global::Tizen.Multimedia.AudioManager.DeviceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7737,9 +6925,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.StreamFocusStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Multimedia.AudioStreamPolicy.StreamFocusStateChanged += x, x => global::Tizen.Multimedia.AudioStreamPolicy.StreamFocusStateChanged -= x); + }, x => global::Tizen.Multimedia.AudioStreamPolicy.StreamFocusStateChanged += x, x => global::Tizen.Multimedia.AudioStreamPolicy.StreamFocusStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7747,9 +6933,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.CameraDeviceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Multimedia.Camera.DeviceStateChanged += x, x => global::Tizen.Multimedia.Camera.DeviceStateChanged -= x); + }, x => global::Tizen.Multimedia.Camera.DeviceStateChanged += x, x => global::Tizen.Multimedia.Camera.DeviceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7757,9 +6941,7 @@ namespace Tizen.Multimedia { void Handler(object sender, global::Tizen.Multimedia.RecorderDeviceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Multimedia.Recorder.DeviceStateChanged += x, x => global::Tizen.Multimedia.Recorder.DeviceStateChanged -= x); + }, x => global::Tizen.Multimedia.Recorder.DeviceStateChanged += x, x => global::Tizen.Multimedia.Recorder.DeviceStateChanged -= x); } } @@ -7777,9 +6959,7 @@ namespace Tizen.Multimedia.Remoting { void Handler(object sender, global::Tizen.Multimedia.Remoting.PlaybackCommandReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Multimedia.Remoting.MediaControlServer.PlaybackCommandReceived += x, x => global::Tizen.Multimedia.Remoting.MediaControlServer.PlaybackCommandReceived -= x); + }, x => global::Tizen.Multimedia.Remoting.MediaControlServer.PlaybackCommandReceived += x, x => global::Tizen.Multimedia.Remoting.MediaControlServer.PlaybackCommandReceived -= x); } } @@ -7797,9 +6977,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.DiscoveryStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Bluetooth.BluetoothAdapter.DiscoveryStateChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.DiscoveryStateChanged -= x); + }, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.DiscoveryStateChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.DiscoveryStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7807,9 +6985,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.NameChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Bluetooth.BluetoothAdapter.NameChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.NameChanged -= x); + }, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.NameChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.NameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7817,9 +6993,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.AdapterLeScanResultChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Bluetooth.BluetoothAdapter.ScanResultChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.ScanResultChanged -= x); + }, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.ScanResultChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.ScanResultChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7827,9 +7001,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Bluetooth.BluetoothAdapter.StateChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.StateChanged -= x); + }, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.StateChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.StateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7837,9 +7009,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.VisibilityDurationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityDurationChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityDurationChanged -= x); + }, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityDurationChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityDurationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7847,9 +7017,7 @@ namespace Tizen.Network.Bluetooth { void Handler(object sender, global::Tizen.Network.Bluetooth.VisibilityModeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityModeChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityModeChanged -= x); + }, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityModeChanged += x, x => global::Tizen.Network.Bluetooth.BluetoothAdapter.VisibilityModeChanged -= x); } } @@ -7867,9 +7035,7 @@ namespace Tizen.Network.Connection { void Handler(object sender, global::Tizen.Network.Connection.ConnectionTypeEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Connection.ConnectionManager.ConnectionTypeChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.ConnectionTypeChanged -= x); + }, x => global::Tizen.Network.Connection.ConnectionManager.ConnectionTypeChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.ConnectionTypeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7877,9 +7043,7 @@ namespace Tizen.Network.Connection { void Handler(object sender, global::Tizen.Network.Connection.EthernetCableStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Connection.ConnectionManager.EthernetCableStateChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.EthernetCableStateChanged -= x); + }, x => global::Tizen.Network.Connection.ConnectionManager.EthernetCableStateChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.EthernetCableStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7887,9 +7051,7 @@ namespace Tizen.Network.Connection { void Handler(object sender, global::Tizen.Network.Connection.AddressEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Connection.ConnectionManager.IPAddressChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.IPAddressChanged -= x); + }, x => global::Tizen.Network.Connection.ConnectionManager.IPAddressChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.IPAddressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7897,9 +7059,7 @@ namespace Tizen.Network.Connection { void Handler(object sender, global::Tizen.Network.Connection.AddressEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Connection.ConnectionManager.ProxyAddressChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.ProxyAddressChanged -= x); + }, x => global::Tizen.Network.Connection.ConnectionManager.ProxyAddressChanged += x, x => global::Tizen.Network.Connection.ConnectionManager.ProxyAddressChanged -= x); } } @@ -7917,9 +7077,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.DeviceInformationFoundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.DeviceInformationFound += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.DeviceInformationFound -= x); + }, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.DeviceInformationFound += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.DeviceInformationFound -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7927,9 +7085,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.FindingErrorOccurredEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.FindingErrorOccurred += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.FindingErrorOccurred -= x); + }, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.FindingErrorOccurred += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.FindingErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7937,9 +7093,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.PlatformInformationFoundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PlatformInformationFound += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PlatformInformationFound -= x); + }, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PlatformInformationFound += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PlatformInformationFound -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7947,9 +7101,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.PresenceReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PresenceReceived += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PresenceReceived -= x); + }, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PresenceReceived += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.PresenceReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7957,9 +7109,7 @@ namespace Tizen.Network.IoTConnectivity { void Handler(object sender, global::Tizen.Network.IoTConnectivity.ResourceFoundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.ResourceFound += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.ResourceFound -= x); + }, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.ResourceFound += x, x => global::Tizen.Network.IoTConnectivity.IoTConnectivityClientManager.ResourceFound -= x); } } @@ -7977,9 +7127,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.ActivationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Nfc.NfcManager.ActivationChanged += x, x => global::Tizen.Network.Nfc.NfcManager.ActivationChanged -= x); + }, x => global::Tizen.Network.Nfc.NfcManager.ActivationChanged += x, x => global::Tizen.Network.Nfc.NfcManager.ActivationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7987,9 +7135,7 @@ namespace Tizen.Network.Nfc { void Handler(object sender, global::Tizen.Network.Nfc.NdefMessageDiscoveredEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.Nfc.NfcManager.NdefMessageDiscovered += x, x => global::Tizen.Network.Nfc.NfcManager.NdefMessageDiscovered -= x); + }, x => global::Tizen.Network.Nfc.NfcManager.NdefMessageDiscovered += x, x => global::Tizen.Network.Nfc.NfcManager.NdefMessageDiscovered -= x); } } @@ -8007,9 +7153,7 @@ namespace Tizen.Network.WiFi { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFi.WiFiManager.BackgroundScanFinished += x, x => global::Tizen.Network.WiFi.WiFiManager.BackgroundScanFinished -= x); + }, x => global::Tizen.Network.WiFi.WiFiManager.BackgroundScanFinished += x, x => global::Tizen.Network.WiFi.WiFiManager.BackgroundScanFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8017,9 +7161,7 @@ namespace Tizen.Network.WiFi { void Handler(object sender, global::Tizen.Network.WiFi.ConnectionStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFi.WiFiManager.ConnectionStateChanged += x, x => global::Tizen.Network.WiFi.WiFiManager.ConnectionStateChanged -= x); + }, x => global::Tizen.Network.WiFi.WiFiManager.ConnectionStateChanged += x, x => global::Tizen.Network.WiFi.WiFiManager.ConnectionStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8027,9 +7169,7 @@ namespace Tizen.Network.WiFi { void Handler(object sender, global::Tizen.Network.WiFi.DeviceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFi.WiFiManager.DeviceStateChanged += x, x => global::Tizen.Network.WiFi.WiFiManager.DeviceStateChanged -= x); + }, x => global::Tizen.Network.WiFi.WiFiManager.DeviceStateChanged += x, x => global::Tizen.Network.WiFi.WiFiManager.DeviceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8037,9 +7177,7 @@ namespace Tizen.Network.WiFi { void Handler(object sender, global::Tizen.Network.WiFi.RssiLevelChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFi.WiFiManager.RssiLevelChanged += x, x => global::Tizen.Network.WiFi.WiFiManager.RssiLevelChanged -= x); + }, x => global::Tizen.Network.WiFi.WiFiManager.RssiLevelChanged += x, x => global::Tizen.Network.WiFi.WiFiManager.RssiLevelChanged -= x); } } @@ -8057,9 +7195,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.ConnectionStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.ConnectionStatusChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.ConnectionStatusChanged -= x); + }, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.ConnectionStatusChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.ConnectionStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8067,9 +7203,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.DeviceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DeviceStateChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DeviceStateChanged -= x); + }, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DeviceStateChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DeviceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8077,9 +7211,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.DiscoveryStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DiscoveryStateChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DiscoveryStateChanged -= x); + }, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DiscoveryStateChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.DiscoveryStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8087,9 +7219,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.PeerFoundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.PeerFound += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.PeerFound -= x); + }, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.PeerFound += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.PeerFound -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8097,9 +7227,7 @@ namespace Tizen.Network.WiFiDirect { void Handler(object sender, global::Tizen.Network.WiFiDirect.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.StateChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.StateChanged -= x); + }, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.StateChanged += x, x => global::Tizen.Network.WiFiDirect.WiFiDirectManager.StateChanged -= x); } } @@ -8117,9 +7245,7 @@ namespace Tizen.Pims.Calendar { void Handler(object sender, global::Tizen.Pims.Calendar.ReminderAlertedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Pims.Calendar.CalendarReminder.ReminderAlerted += x, x => global::Tizen.Pims.Calendar.CalendarReminder.ReminderAlerted -= x); + }, x => global::Tizen.Pims.Calendar.CalendarReminder.ReminderAlerted += x, x => global::Tizen.Pims.Calendar.CalendarReminder.ReminderAlerted -= x); } } @@ -8137,9 +7263,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.BatteryChargingStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.Battery.ChargingStateChanged += x, x => global::Tizen.System.Battery.ChargingStateChanged -= x); + }, x => global::Tizen.System.Battery.ChargingStateChanged += x, x => global::Tizen.System.Battery.ChargingStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8147,9 +7271,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.BatteryLevelChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.Battery.LevelChanged += x, x => global::Tizen.System.Battery.LevelChanged -= x); + }, x => global::Tizen.System.Battery.LevelChanged += x, x => global::Tizen.System.Battery.LevelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8157,9 +7279,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.BatteryPercentChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.Battery.PercentChanged += x, x => global::Tizen.System.Battery.PercentChanged -= x); + }, x => global::Tizen.System.Battery.PercentChanged += x, x => global::Tizen.System.Battery.PercentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8167,9 +7287,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.DisplayStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.Display.StateChanged += x, x => global::Tizen.System.Display.StateChanged -= x); + }, x => global::Tizen.System.Display.StateChanged += x, x => global::Tizen.System.Display.StateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8177,9 +7295,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.LedBrightnessChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.Led.BrightnessChanged += x, x => global::Tizen.System.Led.BrightnessChanged -= x); + }, x => global::Tizen.System.Led.BrightnessChanged += x, x => global::Tizen.System.Led.BrightnessChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8187,9 +7303,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.MediaKeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.MediaKey.Event += x, x => global::Tizen.System.MediaKey.Event -= x); + }, x => global::Tizen.System.MediaKey.Event += x, x => global::Tizen.System.MediaKey.Event -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8197,9 +7311,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.AccessibilityTtsSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.AccessibilityTtsSettingChanged += x, x => global::Tizen.System.SystemSettings.AccessibilityTtsSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.AccessibilityTtsSettingChanged += x, x => global::Tizen.System.SystemSettings.AccessibilityTtsSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8207,9 +7319,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.AdsIdChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.AdsIdChanged += x, x => global::Tizen.System.SystemSettings.AdsIdChanged -= x); + }, x => global::Tizen.System.SystemSettings.AdsIdChanged += x, x => global::Tizen.System.SystemSettings.AdsIdChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8217,9 +7327,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.Data3GNetworkSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.Data3GNetworkSettingChanged += x, x => global::Tizen.System.SystemSettings.Data3GNetworkSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.Data3GNetworkSettingChanged += x, x => global::Tizen.System.SystemSettings.Data3GNetworkSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8227,9 +7335,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.DeviceNameChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.DeviceNameChanged += x, x => global::Tizen.System.SystemSettings.DeviceNameChanged -= x); + }, x => global::Tizen.System.SystemSettings.DeviceNameChanged += x, x => global::Tizen.System.SystemSettings.DeviceNameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8237,9 +7343,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.DisplayScreenRotationAutoSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.DisplayScreenRotationAutoSettingChanged += x, x => global::Tizen.System.SystemSettings.DisplayScreenRotationAutoSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.DisplayScreenRotationAutoSettingChanged += x, x => global::Tizen.System.SystemSettings.DisplayScreenRotationAutoSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8247,9 +7351,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.EmailAlertRingtoneChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.EmailAlertRingtoneChanged += x, x => global::Tizen.System.SystemSettings.EmailAlertRingtoneChanged -= x); + }, x => global::Tizen.System.SystemSettings.EmailAlertRingtoneChanged += x, x => global::Tizen.System.SystemSettings.EmailAlertRingtoneChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8257,9 +7359,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.FontSizeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.FontSizeChanged += x, x => global::Tizen.System.SystemSettings.FontSizeChanged -= x); + }, x => global::Tizen.System.SystemSettings.FontSizeChanged += x, x => global::Tizen.System.SystemSettings.FontSizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8267,9 +7367,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.FontTypeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.FontTypeChanged += x, x => global::Tizen.System.SystemSettings.FontTypeChanged -= x); + }, x => global::Tizen.System.SystemSettings.FontTypeChanged += x, x => global::Tizen.System.SystemSettings.FontTypeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8277,9 +7375,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.IncomingCallRingtoneChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.IncomingCallRingtoneChanged += x, x => global::Tizen.System.SystemSettings.IncomingCallRingtoneChanged -= x); + }, x => global::Tizen.System.SystemSettings.IncomingCallRingtoneChanged += x, x => global::Tizen.System.SystemSettings.IncomingCallRingtoneChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8287,9 +7383,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.LocaleCountryChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.LocaleCountryChanged += x, x => global::Tizen.System.SystemSettings.LocaleCountryChanged -= x); + }, x => global::Tizen.System.SystemSettings.LocaleCountryChanged += x, x => global::Tizen.System.SystemSettings.LocaleCountryChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8297,9 +7391,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.LocaleLanguageChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.LocaleLanguageChanged += x, x => global::Tizen.System.SystemSettings.LocaleLanguageChanged -= x); + }, x => global::Tizen.System.SystemSettings.LocaleLanguageChanged += x, x => global::Tizen.System.SystemSettings.LocaleLanguageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8307,9 +7399,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.LocaleTimeFormat24HourSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.LocaleTimeFormat24HourSettingChanged += x, x => global::Tizen.System.SystemSettings.LocaleTimeFormat24HourSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.LocaleTimeFormat24HourSettingChanged += x, x => global::Tizen.System.SystemSettings.LocaleTimeFormat24HourSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8317,9 +7407,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.LocaleTimeZoneChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.LocaleTimeZoneChanged += x, x => global::Tizen.System.SystemSettings.LocaleTimeZoneChanged -= x); + }, x => global::Tizen.System.SystemSettings.LocaleTimeZoneChanged += x, x => global::Tizen.System.SystemSettings.LocaleTimeZoneChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8327,9 +7415,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.LockScreenAppChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.LockScreenAppChanged += x, x => global::Tizen.System.SystemSettings.LockScreenAppChanged -= x); + }, x => global::Tizen.System.SystemSettings.LockScreenAppChanged += x, x => global::Tizen.System.SystemSettings.LockScreenAppChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8337,9 +7423,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.LockStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.LockStateChanged += x, x => global::Tizen.System.SystemSettings.LockStateChanged -= x); + }, x => global::Tizen.System.SystemSettings.LockStateChanged += x, x => global::Tizen.System.SystemSettings.LockStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8347,9 +7431,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.MotionActivationSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.MotionActivationSettingChanged += x, x => global::Tizen.System.SystemSettings.MotionActivationSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.MotionActivationSettingChanged += x, x => global::Tizen.System.SystemSettings.MotionActivationSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8357,9 +7439,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.MotionSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.MotionSettingChanged += x, x => global::Tizen.System.SystemSettings.MotionSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.MotionSettingChanged += x, x => global::Tizen.System.SystemSettings.MotionSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8367,9 +7447,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.NetworkFlightModeSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.NetworkFlightModeSettingChanged += x, x => global::Tizen.System.SystemSettings.NetworkFlightModeSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.NetworkFlightModeSettingChanged += x, x => global::Tizen.System.SystemSettings.NetworkFlightModeSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8377,9 +7455,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.NetworkWifiNotificationSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.NetworkWifiNotificationSettingChanged += x, x => global::Tizen.System.SystemSettings.NetworkWifiNotificationSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.NetworkWifiNotificationSettingChanged += x, x => global::Tizen.System.SystemSettings.NetworkWifiNotificationSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8387,9 +7463,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.ScreenBacklightTimeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.ScreenBacklightTimeChanged += x, x => global::Tizen.System.SystemSettings.ScreenBacklightTimeChanged -= x); + }, x => global::Tizen.System.SystemSettings.ScreenBacklightTimeChanged += x, x => global::Tizen.System.SystemSettings.ScreenBacklightTimeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8397,9 +7471,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.SoundLockSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.SoundLockSettingChanged += x, x => global::Tizen.System.SystemSettings.SoundLockSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.SoundLockSettingChanged += x, x => global::Tizen.System.SystemSettings.SoundLockSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8407,9 +7479,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.SoundNotificationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.SoundNotificationChanged += x, x => global::Tizen.System.SystemSettings.SoundNotificationChanged -= x); + }, x => global::Tizen.System.SystemSettings.SoundNotificationChanged += x, x => global::Tizen.System.SystemSettings.SoundNotificationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8417,9 +7487,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.SoundNotificationRepetitionPeriodChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.SoundNotificationRepetitionPeriodChanged += x, x => global::Tizen.System.SystemSettings.SoundNotificationRepetitionPeriodChanged -= x); + }, x => global::Tizen.System.SystemSettings.SoundNotificationRepetitionPeriodChanged += x, x => global::Tizen.System.SystemSettings.SoundNotificationRepetitionPeriodChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8427,9 +7495,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.SoundSilentModeSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.SoundSilentModeSettingChanged += x, x => global::Tizen.System.SystemSettings.SoundSilentModeSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.SoundSilentModeSettingChanged += x, x => global::Tizen.System.SystemSettings.SoundSilentModeSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8437,9 +7503,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.SoundTouchSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.SoundTouchSettingChanged += x, x => global::Tizen.System.SystemSettings.SoundTouchSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.SoundTouchSettingChanged += x, x => global::Tizen.System.SystemSettings.SoundTouchSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8447,9 +7511,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.TimeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.TimeChanged += x, x => global::Tizen.System.SystemSettings.TimeChanged -= x); + }, x => global::Tizen.System.SystemSettings.TimeChanged += x, x => global::Tizen.System.SystemSettings.TimeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8457,9 +7519,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.UltraDataSaveChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.UltraDataSaveChanged += x, x => global::Tizen.System.SystemSettings.UltraDataSaveChanged -= x); + }, x => global::Tizen.System.SystemSettings.UltraDataSaveChanged += x, x => global::Tizen.System.SystemSettings.UltraDataSaveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8467,9 +7527,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.UltraDataSavePackageListChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.UltraDataSavePackageListChanged += x, x => global::Tizen.System.SystemSettings.UltraDataSavePackageListChanged -= x); + }, x => global::Tizen.System.SystemSettings.UltraDataSavePackageListChanged += x, x => global::Tizen.System.SystemSettings.UltraDataSavePackageListChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8477,9 +7535,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.UsbDebuggingSettingChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.UsbDebuggingSettingChanged += x, x => global::Tizen.System.SystemSettings.UsbDebuggingSettingChanged -= x); + }, x => global::Tizen.System.SystemSettings.UsbDebuggingSettingChanged += x, x => global::Tizen.System.SystemSettings.UsbDebuggingSettingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8487,9 +7543,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.WallpaperHomeScreenChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.WallpaperHomeScreenChanged += x, x => global::Tizen.System.SystemSettings.WallpaperHomeScreenChanged -= x); + }, x => global::Tizen.System.SystemSettings.WallpaperHomeScreenChanged += x, x => global::Tizen.System.SystemSettings.WallpaperHomeScreenChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8497,9 +7551,7 @@ namespace Tizen.System { void Handler(object sender, global::Tizen.System.WallpaperLockScreenChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.System.SystemSettings.WallpaperLockScreenChanged += x, x => global::Tizen.System.SystemSettings.WallpaperLockScreenChanged -= x); + }, x => global::Tizen.System.SystemSettings.WallpaperLockScreenChanged += x, x => global::Tizen.System.SystemSettings.WallpaperLockScreenChanged -= x); } } @@ -8517,9 +7569,7 @@ namespace Tizen.Telephony { void Handler(object sender, global::Tizen.Telephony.StateEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Telephony.Manager.StateChanged += x, x => global::Tizen.Telephony.Manager.StateChanged -= x); + }, x => global::Tizen.Telephony.Manager.StateChanged += x, x => global::Tizen.Telephony.Manager.StateChanged -= x); } } @@ -8537,9 +7587,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.AccessibilityStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.AccessibilityStateChanged += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.AccessibilityStateChanged -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.AccessibilityStateChanged += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.AccessibilityStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8547,9 +7595,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.CursorPositionUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.CursorPositionUpdated += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.CursorPositionUpdated -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.CursorPositionUpdated += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.CursorPositionUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8557,9 +7603,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.SetDataEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.DataSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.DataSet -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.DataSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.DataSet -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8567,9 +7611,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.DisplayLanguageChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.DisplayLanguageChanged += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.DisplayLanguageChanged -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.DisplayLanguageChanged += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.DisplayLanguageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8577,9 +7619,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.FocusedInEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedIn += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedIn -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedIn += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedIn -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8587,9 +7627,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.FocusedOutEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedOut += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedOut -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedOut += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.FocusedOut -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8597,9 +7635,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.InputContextReset += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.InputContextReset -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.InputContextReset += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.InputContextReset -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8607,9 +7643,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.LanguageSetEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.LanguageSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.LanguageSet -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.LanguageSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.LanguageSet -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8617,9 +7651,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.LayoutSetEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.LayoutSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.LayoutSet -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.LayoutSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.LayoutSet -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8627,9 +7659,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.ReturnKeySetEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeySet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeySet -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeySet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeySet -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8637,9 +7667,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.ReturnKeyStateSetEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeyStateSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeyStateSet -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeyStateSet += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.ReturnKeyStateSet -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8647,9 +7675,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.RotationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.RotationChanged += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.RotationChanged -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.RotationChanged += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.RotationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8657,9 +7683,7 @@ namespace Tizen.Uix.InputMethod { void Handler(object sender, global::Tizen.Uix.InputMethod.SurroundingTextUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.InputMethod.InputMethodEditor.SurroundingTextUpdated += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.SurroundingTextUpdated -= x); + }, x => global::Tizen.Uix.InputMethod.InputMethodEditor.SurroundingTextUpdated += x, x => global::Tizen.Uix.InputMethod.InputMethodEditor.SurroundingTextUpdated -= x); } } @@ -8677,9 +7701,7 @@ namespace Tizen.Uix.VoiceControl { void Handler(object sender, global::Tizen.Uix.VoiceControl.CurrentLanguageChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.VoiceControl.VoiceControlClient.CurrentLanguageChanged += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.CurrentLanguageChanged -= x); + }, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.CurrentLanguageChanged += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.CurrentLanguageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8687,9 +7709,7 @@ namespace Tizen.Uix.VoiceControl { void Handler(object sender, global::Tizen.Uix.VoiceControl.ErrorOccuredEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ErrorOccured += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ErrorOccured -= x); + }, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ErrorOccured += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ErrorOccured -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8697,9 +7717,7 @@ namespace Tizen.Uix.VoiceControl { void Handler(object sender, global::Tizen.Uix.VoiceControl.RecognitionResultEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.VoiceControl.VoiceControlClient.RecognitionResult += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.RecognitionResult -= x); + }, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.RecognitionResult += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.RecognitionResult -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8707,9 +7725,7 @@ namespace Tizen.Uix.VoiceControl { void Handler(object sender, global::Tizen.Uix.VoiceControl.ServiceStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ServiceStateChanged += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ServiceStateChanged -= x); + }, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ServiceStateChanged += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.ServiceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8717,8 +7733,6 @@ namespace Tizen.Uix.VoiceControl { void Handler(object sender, global::Tizen.Uix.VoiceControl.StateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Tizen.Uix.VoiceControl.VoiceControlClient.StateChanged += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.StateChanged -= x); + }, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.StateChanged += x, x => global::Tizen.Uix.VoiceControl.VoiceControlClient.StateChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.net461.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.net472.approved.txt similarity index 96% rename from src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.net461.approved.txt rename to src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.net472.approved.txt index 6710757..396f469 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.net461.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.net472.approved.txt @@ -40,8 +40,6 @@ namespace Uno { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.net5.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.net5.0.approved.txt new file mode 100644 index 0000000..396f469 --- /dev/null +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.net5.0.approved.txt @@ -0,0 +1,45 @@ + +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + +namespace Uno +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxILoadableEvents Events(this global::Uno.ILoadable item) => new RxILoadableEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxILoadableEvents + { + private readonly global::Uno.ILoadable _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxILoadableEvents(global::Uno.ILoadable data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Loaded += x, x => _data.Loaded -= x); + } +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.netstandard2.0.approved.txt index 6710757..396f469 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.netstandard2.0.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.netstandard2.0.approved.txt @@ -40,8 +40,6 @@ namespace Uno { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.uap10.0.17763.approved.txt index 6710757..396f469 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.uap10.0.17763.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.Core.1.27.0.uap10.0.17763.approved.txt @@ -40,8 +40,6 @@ namespace Uno { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.monoandroid80.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.monoandroid80.approved.txt index 7bd35ce..44fbc69 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.monoandroid80.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.monoandroid80.approved.txt @@ -40,9 +40,7 @@ namespace Android.Support.V4.View { void Handler(object sender, global::Android.Support.V4.View.ViewPager.AdapterChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AdapterChange += x, x => _data.AdapterChange -= x); + }, x => _data.AdapterChange += x, x => _data.AdapterChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -50,9 +48,7 @@ namespace Android.Support.V4.View { void Handler(object sender, global::Android.Support.V4.View.ViewPager.PageScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PageScrolled += x, x => _data.PageScrolled -= x); + }, x => _data.PageScrolled += x, x => _data.PageScrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -60,9 +56,7 @@ namespace Android.Support.V4.View { void Handler(object sender, global::Android.Support.V4.View.ViewPager.PageScrollStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PageScrollStateChanged += x, x => _data.PageScrollStateChanged -= x); + }, x => _data.PageScrollStateChanged += x, x => _data.PageScrollStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -70,9 +64,7 @@ namespace Android.Support.V4.View { void Handler(object sender, global::Android.Support.V4.View.ViewPager.PageSelectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PageSelected += x, x => _data.PageSelected -= x); + }, x => _data.PageSelected += x, x => _data.PageSelected -= x); } } @@ -111,9 +103,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); + }, x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -121,9 +111,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); + }, x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -131,9 +119,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); + }, x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -141,9 +127,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); + }, x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); } } @@ -182,9 +166,7 @@ namespace Android.Support.V7.Widget { void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewAttachedToWindow += x, x => _data.ChildViewAttachedToWindow -= x); + }, x => _data.ChildViewAttachedToWindow += x, x => _data.ChildViewAttachedToWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -192,9 +174,7 @@ namespace Android.Support.V7.Widget { void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewDetachedFromWindow += x, x => _data.ChildViewDetachedFromWindow -= x); + }, x => _data.ChildViewDetachedFromWindow += x, x => _data.ChildViewDetachedFromWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -202,9 +182,7 @@ namespace Android.Support.V7.Widget { void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InterceptTouchEvent += x, x => _data.InterceptTouchEvent -= x); + }, x => _data.InterceptTouchEvent += x, x => _data.InterceptTouchEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -212,9 +190,7 @@ namespace Android.Support.V7.Widget { void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RecyclerEvent += x, x => _data.RecyclerEvent -= x); + }, x => _data.RecyclerEvent += x, x => _data.RecyclerEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -222,9 +198,7 @@ namespace Android.Support.V7.Widget { void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RequestDisallowInterceptTouchEvent += x, x => _data.RequestDisallowInterceptTouchEvent -= x); + }, x => _data.RequestDisallowInterceptTouchEvent += x, x => _data.RequestDisallowInterceptTouchEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -232,9 +206,7 @@ namespace Android.Support.V7.Widget { void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); + }, x => _data.TouchEvent += x, x => _data.TouchEvent -= x); } } @@ -277,9 +249,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); + }, x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -287,9 +257,7 @@ namespace Android.Views { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -297,9 +265,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); + }, x => _data.ContextClick += x, x => _data.ContextClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -307,9 +273,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); + }, x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -317,9 +281,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); + }, x => _data.Drag += x, x => _data.Drag -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -327,9 +289,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); + }, x => _data.FocusChange += x, x => _data.FocusChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -337,9 +297,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); + }, x => _data.GenericMotion += x, x => _data.GenericMotion -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -347,9 +305,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); + }, x => _data.Hover += x, x => _data.Hover -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -357,9 +313,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -367,9 +321,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); + }, x => _data.LayoutChange += x, x => _data.LayoutChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -377,9 +329,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); + }, x => _data.LongClick += x, x => _data.LongClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -387,9 +337,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); + }, x => _data.ScrollChange += x, x => _data.ScrollChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -397,9 +345,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); + }, x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -407,9 +353,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); + }, x => _data.Touch += x, x => _data.Touch -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -417,9 +361,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); + }, x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -427,9 +369,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); + }, x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); } /// @@ -454,9 +394,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); + }, x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -464,9 +402,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); + }, x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -474,9 +410,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); + }, x => _data.AnimationStart += x, x => _data.AnimationStart -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -484,9 +418,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); + }, x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -494,9 +426,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); + }, x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); } } @@ -555,9 +485,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.AbsListView.RecyclerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Recycler += x, x => _data.Recycler -= x); + }, x => _data.Recycler += x, x => _data.Recycler -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -565,9 +493,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.AbsListView.ScrollEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scroll += x, x => _data.Scroll -= x); + }, x => _data.Scroll += x, x => _data.Scroll -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -575,9 +501,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.AbsListView.ScrollStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollStateChanged += x, x => _data.ScrollStateChanged -= x); + }, x => _data.ScrollStateChanged += x, x => _data.ScrollStateChanged -= x); } /// @@ -602,9 +526,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.AdapterView.ItemClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemClick += x, x => _data.ItemClick -= x); + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -612,9 +534,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.AdapterView.ItemLongClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongClick += x, x => _data.ItemLongClick -= x); + }, x => _data.ItemLongClick += x, x => _data.ItemLongClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -622,9 +542,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.AdapterView.ItemSelectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -633,9 +551,7 @@ namespace Android.Widget { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelectionCleared += x, x => _data.ItemSelectionCleared -= x); + }, x => _data.ItemSelectionCleared += x, x => _data.ItemSelectionCleared -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -643,9 +559,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.AdapterView.NothingSelectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NothingSelected += x, x => _data.NothingSelected -= x); + }, x => _data.NothingSelected += x, x => _data.NothingSelected -= x); } /// @@ -670,9 +584,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.CompoundButton.CheckedChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChange += x, x => _data.CheckedChange -= x); + }, x => _data.CheckedChange += x, x => _data.CheckedChange -= x); } /// @@ -697,9 +609,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SearchView.CloseEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Close += x, x => _data.Close -= x); + }, x => _data.Close += x, x => _data.Close -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -707,9 +617,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SearchView.QueryTextChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.QueryTextChange += x, x => _data.QueryTextChange -= x); + }, x => _data.QueryTextChange += x, x => _data.QueryTextChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -717,9 +625,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.QueryTextFocusChange += x, x => _data.QueryTextFocusChange -= x); + }, x => _data.QueryTextFocusChange += x, x => _data.QueryTextFocusChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -727,9 +633,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SearchView.QueryTextSubmitEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.QueryTextSubmit += x, x => _data.QueryTextSubmit -= x); + }, x => _data.QueryTextSubmit += x, x => _data.QueryTextSubmit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -737,9 +641,7 @@ namespace Android.Widget { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchClick += x, x => _data.SearchClick -= x); + }, x => _data.SearchClick += x, x => _data.SearchClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -747,9 +649,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SearchView.SuggestionClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SuggestionClick += x, x => _data.SuggestionClick -= x); + }, x => _data.SuggestionClick += x, x => _data.SuggestionClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -757,9 +657,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SearchView.SuggestionSelectEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SuggestionSelect += x, x => _data.SuggestionSelect -= x); + }, x => _data.SuggestionSelect += x, x => _data.SuggestionSelect -= x); } /// @@ -784,9 +682,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SeekBar.ProgressChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -794,9 +690,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SeekBar.StartTrackingTouchEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StartTrackingTouch += x, x => _data.StartTrackingTouch -= x); + }, x => _data.StartTrackingTouch += x, x => _data.StartTrackingTouch -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -804,9 +698,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SeekBar.StopTrackingTouchEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StopTrackingTouch += x, x => _data.StopTrackingTouch -= x); + }, x => _data.StopTrackingTouch += x, x => _data.StopTrackingTouch -= x); } /// @@ -831,9 +723,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); + }, x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -841,9 +731,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); + }, x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -851,9 +739,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); + }, x => _data.EditorAction += x, x => _data.EditorAction -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -861,9 +747,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } } @@ -906,9 +790,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.ActionMode e) => eventHandler(e); return Handler; - } - - , x => _data.ActionModeFinished += x, x => _data.ActionModeFinished -= x); + }, x => _data.ActionModeFinished += x, x => _data.ActionModeFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -916,9 +798,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.ActionMode e) => eventHandler(e); return Handler; - } - - , x => _data.ActionModeStarted += x, x => _data.ActionModeStarted -= x); + }, x => _data.ActionModeStarted += x, x => _data.ActionModeStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -926,9 +806,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.ActivityReenterEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ActivityReenter += x, x => _data.ActivityReenter -= x); + }, x => _data.ActivityReenter += x, x => _data.ActivityReenter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -936,9 +814,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.ActivityResultEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ActivityResult += x, x => _data.ActivityResult -= x); + }, x => _data.ActivityResult += x, x => _data.ActivityResult -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -946,9 +822,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AttachedToWindow += x, x => _data.AttachedToWindow -= x); + }, x => _data.AttachedToWindow += x, x => _data.AttachedToWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -956,9 +830,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.App.Fragment e) => eventHandler(e); return Handler; - } - - , x => _data.AttachFragment += x, x => _data.AttachFragment -= x); + }, x => _data.AttachFragment += x, x => _data.AttachFragment -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -966,9 +838,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackPressed += x, x => _data.BackPressed -= x); + }, x => _data.BackPressed += x, x => _data.BackPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -976,9 +846,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.ChildTitleChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildTitleChanged += x, x => _data.ChildTitleChanged -= x); + }, x => _data.ChildTitleChanged += x, x => _data.ChildTitleChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -986,9 +854,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Content.Res.Configuration e) => eventHandler(e); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -996,9 +862,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContentChanged += x, x => _data.ContentChanged -= x); + }, x => _data.ContentChanged += x, x => _data.ContentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1006,9 +870,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.IMenuItem e) => eventHandler(e); return Handler; - } - - , x => _data.ContextItemSelected += x, x => _data.ContextItemSelected -= x); + }, x => _data.ContextItemSelected += x, x => _data.ContextItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1016,9 +878,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.IMenu e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuClosed += x, x => _data.ContextMenuClosed -= x); + }, x => _data.ContextMenuClosed += x, x => _data.ContextMenuClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1026,9 +886,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.OS.Bundle e) => eventHandler(e); return Handler; - } - - , x => _data.Create += x, x => _data.Create -= x); + }, x => _data.Create += x, x => _data.Create -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1036,9 +894,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.CreateContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CreateContextMenu += x, x => _data.CreateContextMenu -= x); + }, x => _data.CreateContextMenu += x, x => _data.CreateContextMenu -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1046,9 +902,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CreateDescriptionFormatted += x, x => _data.CreateDescriptionFormatted -= x); + }, x => _data.CreateDescriptionFormatted += x, x => _data.CreateDescriptionFormatted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1056,9 +910,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.App.TaskStackBuilder e) => eventHandler(e); return Handler; - } - - , x => _data.CreateNavigateUpTaskStack += x, x => _data.CreateNavigateUpTaskStack -= x); + }, x => _data.CreateNavigateUpTaskStack += x, x => _data.CreateNavigateUpTaskStack -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1066,9 +918,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.IMenu e) => eventHandler(e); return Handler; - } - - , x => _data.CreateOptionsMenu += x, x => _data.CreateOptionsMenu -= x); + }, x => _data.CreateOptionsMenu += x, x => _data.CreateOptionsMenu -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1076,9 +926,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.CreatePanelMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CreatePanelMenu += x, x => _data.CreatePanelMenu -= x); + }, x => _data.CreatePanelMenu += x, x => _data.CreatePanelMenu -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1086,9 +934,7 @@ namespace Uno.UI { void Handler(object sender, int e) => eventHandler(e); return Handler; - } - - , x => _data.CreatePanelView += x, x => _data.CreatePanelView -= x); + }, x => _data.CreatePanelView += x, x => _data.CreatePanelView -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1096,9 +942,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.CreateThumbnailEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CreateThumbnail += x, x => _data.CreateThumbnail -= x); + }, x => _data.CreateThumbnail += x, x => _data.CreateThumbnail -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1106,9 +950,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.CreateViewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CreateView += x, x => _data.CreateView -= x); + }, x => _data.CreateView += x, x => _data.CreateView -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1116,9 +958,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.CreateViewWithParentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CreateViewWithParent += x, x => _data.CreateViewWithParent -= x); + }, x => _data.CreateViewWithParent += x, x => _data.CreateViewWithParent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1126,9 +966,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.CreateWithPersistedStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CreateWithPersistedState += x, x => _data.CreateWithPersistedState -= x); + }, x => _data.CreateWithPersistedState += x, x => _data.CreateWithPersistedState -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1136,9 +974,7 @@ namespace Uno.UI { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1146,9 +982,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Destroy += x, x => _data.Destroy -= x); + }, x => _data.Destroy += x, x => _data.Destroy -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1156,9 +990,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DetachedFromWindow += x, x => _data.DetachedFromWindow -= x); + }, x => _data.DetachedFromWindow += x, x => _data.DetachedFromWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1166,9 +998,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EnterAnimationComplete += x, x => _data.EnterAnimationComplete -= x); + }, x => _data.EnterAnimationComplete += x, x => _data.EnterAnimationComplete -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1176,9 +1006,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.MotionEvent e) => eventHandler(e); return Handler; - } - - , x => _data.GenericMotionEvent += x, x => _data.GenericMotionEvent -= x); + }, x => _data.GenericMotionEvent += x, x => _data.GenericMotionEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1186,9 +1014,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.KeyDownEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1196,9 +1022,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.KeyLongPressEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyLongPress += x, x => _data.KeyLongPress -= x); + }, x => _data.KeyLongPress += x, x => _data.KeyLongPress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1206,9 +1030,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.KeyMultipleEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyMultiple += x, x => _data.KeyMultiple -= x); + }, x => _data.KeyMultiple += x, x => _data.KeyMultiple -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1216,9 +1038,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.KeyShortcutEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyShortcut += x, x => _data.KeyShortcut -= x); + }, x => _data.KeyShortcut += x, x => _data.KeyShortcut -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1226,9 +1046,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.KeyUpEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1236,9 +1054,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LowMemory += x, x => _data.LowMemory -= x); + }, x => _data.LowMemory += x, x => _data.LowMemory -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1246,9 +1062,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.MenuOpenedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MenuOpened += x, x => _data.MenuOpened -= x); + }, x => _data.MenuOpened += x, x => _data.MenuOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1256,9 +1070,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigateUp += x, x => _data.NavigateUp -= x); + }, x => _data.NavigateUp += x, x => _data.NavigateUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1266,9 +1078,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.App.Activity e) => eventHandler(e); return Handler; - } - - , x => _data.NavigateUpFromChild += x, x => _data.NavigateUpFromChild -= x); + }, x => _data.NavigateUpFromChild += x, x => _data.NavigateUpFromChild -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1276,9 +1086,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Content.Intent e) => eventHandler(e); return Handler; - } - - , x => _data.NewIntent += x, x => _data.NewIntent -= x); + }, x => _data.NewIntent += x, x => _data.NewIntent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1286,9 +1094,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.IMenuItem e) => eventHandler(e); return Handler; - } - - , x => _data.OptionsItemSelected += x, x => _data.OptionsItemSelected -= x); + }, x => _data.OptionsItemSelected += x, x => _data.OptionsItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1296,9 +1102,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.IMenu e) => eventHandler(e); return Handler; - } - - , x => _data.OptionsMenuClosed += x, x => _data.OptionsMenuClosed -= x); + }, x => _data.OptionsMenuClosed += x, x => _data.OptionsMenuClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1306,9 +1110,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.PanelClosedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanelClosed += x, x => _data.PanelClosed -= x); + }, x => _data.PanelClosed += x, x => _data.PanelClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1316,9 +1118,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pause += x, x => _data.Pause -= x); + }, x => _data.Pause += x, x => _data.Pause -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1326,9 +1126,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.OS.Bundle e) => eventHandler(e); return Handler; - } - - , x => _data.PostCreate += x, x => _data.PostCreate -= x); + }, x => _data.PostCreate += x, x => _data.PostCreate -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1336,9 +1134,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.PostCreateWithPersistedStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PostCreateWithPersistedState += x, x => _data.PostCreateWithPersistedState -= x); + }, x => _data.PostCreateWithPersistedState += x, x => _data.PostCreateWithPersistedState -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1346,9 +1142,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PostResume += x, x => _data.PostResume -= x); + }, x => _data.PostResume += x, x => _data.PostResume -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1356,9 +1150,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.App.TaskStackBuilder e) => eventHandler(e); return Handler; - } - - , x => _data.PrepareNavigateUpTaskStack += x, x => _data.PrepareNavigateUpTaskStack -= x); + }, x => _data.PrepareNavigateUpTaskStack += x, x => _data.PrepareNavigateUpTaskStack -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1366,9 +1158,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.IMenu e) => eventHandler(e); return Handler; - } - - , x => _data.PrepareOptionsMenu += x, x => _data.PrepareOptionsMenu -= x); + }, x => _data.PrepareOptionsMenu += x, x => _data.PrepareOptionsMenu -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1376,9 +1166,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.PrepareOptionsPanelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PrepareOptionsPanel += x, x => _data.PrepareOptionsPanel -= x); + }, x => _data.PrepareOptionsPanel += x, x => _data.PrepareOptionsPanel -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1386,9 +1174,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.PreparePanelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PreparePanel += x, x => _data.PreparePanel -= x); + }, x => _data.PreparePanel += x, x => _data.PreparePanel -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1396,9 +1182,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.OS.Bundle e) => eventHandler(e); return Handler; - } - - , x => _data.ProvideAssistData += x, x => _data.ProvideAssistData -= x); + }, x => _data.ProvideAssistData += x, x => _data.ProvideAssistData -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1406,9 +1190,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.RequestPermissionsResultWithResultsEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RequestPermissionsResultWithResults += x, x => _data.RequestPermissionsResultWithResults -= x); + }, x => _data.RequestPermissionsResultWithResults += x, x => _data.RequestPermissionsResultWithResults -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1416,9 +1198,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Restart += x, x => _data.Restart -= x); + }, x => _data.Restart += x, x => _data.Restart -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1426,9 +1206,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.OS.Bundle e) => eventHandler(e); return Handler; - } - - , x => _data.RestoreInstanceState += x, x => _data.RestoreInstanceState -= x); + }, x => _data.RestoreInstanceState += x, x => _data.RestoreInstanceState -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1436,9 +1214,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.RestoreInstanceStateWithPersistedStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RestoreInstanceStateWithPersistedState += x, x => _data.RestoreInstanceStateWithPersistedState -= x); + }, x => _data.RestoreInstanceStateWithPersistedState += x, x => _data.RestoreInstanceStateWithPersistedState -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1446,9 +1222,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resume += x, x => _data.Resume -= x); + }, x => _data.Resume += x, x => _data.Resume -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1456,9 +1230,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResumeFragments += x, x => _data.ResumeFragments -= x); + }, x => _data.ResumeFragments += x, x => _data.ResumeFragments -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1466,9 +1238,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RetainCustomNonConfigurationInstance += x, x => _data.RetainCustomNonConfigurationInstance -= x); + }, x => _data.RetainCustomNonConfigurationInstance += x, x => _data.RetainCustomNonConfigurationInstance -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1476,9 +1246,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.OS.Bundle e) => eventHandler(e); return Handler; - } - - , x => _data.SaveInstanceState += x, x => _data.SaveInstanceState -= x); + }, x => _data.SaveInstanceState += x, x => _data.SaveInstanceState -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1486,9 +1254,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.SaveInstanceStateWithPersistedStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SaveInstanceStateWithPersistedState += x, x => _data.SaveInstanceStateWithPersistedState -= x); + }, x => _data.SaveInstanceStateWithPersistedState += x, x => _data.SaveInstanceStateWithPersistedState -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1496,9 +1262,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchRequested += x, x => _data.SearchRequested -= x); + }, x => _data.SearchRequested += x, x => _data.SearchRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1506,9 +1270,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Start += x, x => _data.Start -= x); + }, x => _data.Start += x, x => _data.Start -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1516,9 +1278,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateNotSaved += x, x => _data.StateNotSaved -= x); + }, x => _data.StateNotSaved += x, x => _data.StateNotSaved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1526,9 +1286,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Stop += x, x => _data.Stop -= x); + }, x => _data.Stop += x, x => _data.Stop -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1536,9 +1294,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.TitleChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TitleChanged += x, x => _data.TitleChanged -= x); + }, x => _data.TitleChanged += x, x => _data.TitleChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1546,9 +1302,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.MotionEvent e) => eventHandler(e); return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); + }, x => _data.TouchEvent += x, x => _data.TouchEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1556,9 +1310,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.MotionEvent e) => eventHandler(e); return Handler; - } - - , x => _data.TrackballEvent += x, x => _data.TrackballEvent -= x); + }, x => _data.TrackballEvent += x, x => _data.TrackballEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1566,9 +1318,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Content.TrimMemory e) => eventHandler(e); return Handler; - } - - , x => _data.TrimMemory += x, x => _data.TrimMemory -= x); + }, x => _data.TrimMemory += x, x => _data.TrimMemory -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1576,9 +1326,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UserInteraction += x, x => _data.UserInteraction -= x); + }, x => _data.UserInteraction += x, x => _data.UserInteraction -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1586,9 +1334,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UserLeaveHint += x, x => _data.UserLeaveHint -= x); + }, x => _data.UserLeaveHint += x, x => _data.UserLeaveHint -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1596,9 +1342,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VisibleBehindCanceled += x, x => _data.VisibleBehindCanceled -= x); + }, x => _data.VisibleBehindCanceled += x, x => _data.VisibleBehindCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1606,9 +1350,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.WindowManagerLayoutParams e) => eventHandler(e); return Handler; - } - - , x => _data.WindowAttributesChanged += x, x => _data.WindowAttributesChanged -= x); + }, x => _data.WindowAttributesChanged += x, x => _data.WindowAttributesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1616,9 +1358,7 @@ namespace Uno.UI { void Handler(object sender, bool e) => eventHandler(e); return Handler; - } - - , x => _data.WindowFocusChanged += x, x => _data.WindowFocusChanged -= x); + }, x => _data.WindowFocusChanged += x, x => _data.WindowFocusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1626,9 +1366,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.ActionMode.ICallback e) => eventHandler(e); return Handler; - } - - , x => _data.WindowStartingActionMode += x, x => _data.WindowStartingActionMode -= x); + }, x => _data.WindowStartingActionMode += x, x => _data.WindowStartingActionMode -= x); } /// @@ -1653,9 +1391,7 @@ namespace Uno.UI { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -1694,9 +1430,7 @@ namespace Uno.UI.Common { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } } @@ -1787,9 +1521,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1814,9 +1546,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1824,9 +1554,7 @@ namespace Uno.UI.Controls { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -1851,9 +1579,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1878,9 +1604,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1905,9 +1629,7 @@ namespace Uno.UI.Controls { void Handler(object sender, global::Uno.UI.Controls.ItemsSourceChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsSourceChanged += x, x => _data.ItemsSourceChanged -= x); + }, x => _data.ItemsSourceChanged += x, x => _data.ItemsSourceChanged -= x); } /// @@ -1932,9 +1654,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1959,9 +1679,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1986,9 +1704,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1996,9 +1712,7 @@ namespace Uno.UI.Controls { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -2023,9 +1737,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2033,9 +1745,7 @@ namespace Uno.UI.Controls { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -2060,9 +1770,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -2087,9 +1795,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -2114,9 +1820,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -2141,9 +1845,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2151,9 +1853,7 @@ namespace Uno.UI.Controls { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -2178,9 +1878,7 @@ namespace Uno.UI.Controls { void Handler(object sender, global::Uno.UI.Controls.ScreenChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScreenChanged += x, x => _data.ScreenChanged -= x); + }, x => _data.ScreenChanged += x, x => _data.ScreenChanged -= x); } } @@ -2231,9 +1929,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2241,9 +1937,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2251,9 +1945,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Controls.ItemClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemClick += x, x => _data.ItemClick -= x); + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2261,9 +1953,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2271,9 +1961,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2281,9 +1969,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2291,9 +1977,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2301,9 +1985,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2311,9 +1993,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2321,9 +2001,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -2348,9 +2026,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2358,9 +2034,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2368,9 +2042,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2378,9 +2050,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2388,9 +2058,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2398,9 +2066,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2408,9 +2074,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2418,9 +2082,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2428,9 +2090,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -2455,9 +2115,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2465,9 +2123,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2475,9 +2131,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2485,9 +2139,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2495,9 +2147,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2505,9 +2155,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2515,9 +2163,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2525,9 +2171,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2535,9 +2179,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2545,9 +2187,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -2572,9 +2212,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2582,9 +2220,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2592,9 +2228,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Controls.ItemClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemClick += x, x => _data.ItemClick -= x); + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2602,9 +2236,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2612,9 +2244,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2622,9 +2252,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2632,9 +2260,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2642,9 +2268,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2652,9 +2276,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2662,9 +2284,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2672,9 +2292,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } } @@ -2713,9 +2331,7 @@ namespace Uno.Xaml { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnNameScopeInitializationComplete += x, x => _data.OnNameScopeInitializationComplete -= x); + }, x => _data.OnNameScopeInitializationComplete += x, x => _data.OnNameScopeInitializationComplete -= x); } } @@ -2754,9 +2370,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageContentGroupStaging += x, x => _data.PackageContentGroupStaging -= x); + }, x => _data.PackageContentGroupStaging += x, x => _data.PackageContentGroupStaging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2764,9 +2378,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageInstalling += x, x => _data.PackageInstalling -= x); + }, x => _data.PackageInstalling += x, x => _data.PackageInstalling -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2774,9 +2386,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageStaging += x, x => _data.PackageStaging -= x); + }, x => _data.PackageStaging += x, x => _data.PackageStaging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2784,9 +2394,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2794,9 +2402,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2804,9 +2410,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); } } @@ -2845,9 +2449,7 @@ namespace Windows.ApplicationModel.Activation { void Handler(global::Windows.ApplicationModel.Activation.SplashScreen sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); } } @@ -2886,9 +2488,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageInstalled += x, x => _data.PackageInstalled -= x); + }, x => _data.PackageInstalled += x, x => _data.PackageInstalled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2896,9 +2496,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2906,9 +2504,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2916,9 +2512,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUpdated += x, x => _data.PackageUpdated -= x); + }, x => _data.PackageUpdated += x, x => _data.PackageUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2926,9 +2520,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); } } @@ -2971,9 +2563,7 @@ namespace Windows.ApplicationModel.Appointments { void Handler(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } /// @@ -2998,9 +2588,7 @@ namespace Windows.ApplicationModel.Appointments { void Handler(global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); } } @@ -3039,9 +2627,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CancelMeetingRequested += x, x => _data.CancelMeetingRequested -= x); + }, x => _data.CancelMeetingRequested += x, x => _data.CancelMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3049,9 +2635,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateOrUpdateAppointmentRequested += x, x => _data.CreateOrUpdateAppointmentRequested -= x); + }, x => _data.CreateOrUpdateAppointmentRequested += x, x => _data.CreateOrUpdateAppointmentRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3059,9 +2643,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3069,9 +2651,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3079,9 +2659,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3089,9 +2667,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); } } @@ -3130,9 +2706,7 @@ namespace Windows.ApplicationModel.AppService { void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3140,9 +2714,7 @@ namespace Windows.ApplicationModel.AppService { void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServiceClosed += x, x => _data.ServiceClosed -= x); + }, x => _data.ServiceClosed += x, x => _data.ServiceClosed -= x); } } @@ -3193,9 +2765,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3203,9 +2773,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Progress += x, x => _data.Progress -= x); + }, x => _data.Progress += x, x => _data.Progress -= x); } /// @@ -3230,9 +2798,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BackgroundActivated += x, x => _data.BackgroundActivated -= x); + }, x => _data.BackgroundActivated += x, x => _data.BackgroundActivated -= x); } /// @@ -3257,9 +2823,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); } /// @@ -3284,9 +2848,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3294,9 +2856,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Progress += x, x => _data.Progress -= x); + }, x => _data.Progress += x, x => _data.Progress -= x); } } @@ -3347,9 +2907,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteParticipantComposingChanged += x, x => _data.RemoteParticipantComposingChanged -= x); + }, x => _data.RemoteParticipantComposingChanged += x, x => _data.RemoteParticipantComposingChanged -= x); } /// @@ -3374,9 +2932,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageChanged += x, x => _data.MessageChanged -= x); + }, x => _data.MessageChanged += x, x => _data.MessageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3384,9 +2940,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); } /// @@ -3411,9 +2965,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageAvailableChanged += x, x => _data.MessageAvailableChanged -= x); + }, x => _data.MessageAvailableChanged += x, x => _data.MessageAvailableChanged -= x); } /// @@ -3438,9 +2990,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServiceKindSupportedChanged += x, x => _data.ServiceKindSupportedChanged -= x); + }, x => _data.ServiceKindSupportedChanged += x, x => _data.ServiceKindSupportedChanged -= x); } } @@ -3491,9 +3041,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); } /// @@ -3518,9 +3066,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } /// @@ -3545,9 +3091,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3555,9 +3099,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LaunchFullAppRequested += x, x => _data.LaunchFullAppRequested -= x); + }, x => _data.LaunchFullAppRequested += x, x => _data.LaunchFullAppRequested -= x); } /// @@ -3582,9 +3124,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); } } @@ -3623,9 +3163,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateOrUpdateContactRequested += x, x => _data.CreateOrUpdateContactRequested -= x); + }, x => _data.CreateOrUpdateContactRequested += x, x => _data.CreateOrUpdateContactRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3633,9 +3171,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeleteContactRequested += x, x => _data.DeleteContactRequested -= x); + }, x => _data.DeleteContactRequested += x, x => _data.DeleteContactRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3643,9 +3179,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3653,9 +3187,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); } } @@ -3694,9 +3226,7 @@ namespace Windows.ApplicationModel.Contacts.Provider { void Handler(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContactRemoved += x, x => _data.ContactRemoved -= x); + }, x => _data.ContactRemoved += x, x => _data.ContactRemoved -= x); } } @@ -3743,9 +3273,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3753,9 +3281,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HostedViewClosing += x, x => _data.HostedViewClosing -= x); + }, x => _data.HostedViewClosing += x, x => _data.HostedViewClosing -= x); } /// @@ -3780,9 +3306,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3790,9 +3314,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LayoutMetricsChanged += x, x => _data.LayoutMetricsChanged -= x); + }, x => _data.LayoutMetricsChanged += x, x => _data.LayoutMetricsChanged -= x); } /// @@ -3817,9 +3339,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UnhandledErrorDetected += x, x => _data.UnhandledErrorDetected -= x); + }, x => _data.UnhandledErrorDetected += x, x => _data.UnhandledErrorDetected -= x); } } @@ -3862,9 +3382,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3872,9 +3390,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3882,9 +3398,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShareCompleted += x, x => _data.ShareCompleted -= x); + }, x => _data.ShareCompleted += x, x => _data.ShareCompleted -= x); } /// @@ -3909,9 +3423,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataRequested += x, x => _data.DataRequested -= x); + }, x => _data.DataRequested += x, x => _data.DataRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3919,9 +3431,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShareProvidersRequested += x, x => _data.ShareProvidersRequested -= x); + }, x => _data.ShareProvidersRequested += x, x => _data.ShareProvidersRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3929,9 +3439,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetApplicationChosen += x, x => _data.TargetApplicationChosen -= x); + }, x => _data.TargetApplicationChosen += x, x => _data.TargetApplicationChosen -= x); } } @@ -3970,9 +3478,7 @@ namespace Windows.ApplicationModel.DataTransfer.DragDrop.Core { void Handler(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetRequested += x, x => _data.TargetRequested -= x); + }, x => _data.TargetRequested += x, x => _data.TargetRequested -= x); } } @@ -4015,9 +3521,7 @@ namespace Windows.ApplicationModel.Email { void Handler(global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MailboxChanged += x, x => _data.MailboxChanged -= x); + }, x => _data.MailboxChanged += x, x => _data.MailboxChanged -= x); } /// @@ -4042,9 +3546,7 @@ namespace Windows.ApplicationModel.Email { void Handler(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } } @@ -4083,9 +3585,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateFolderRequested += x, x => _data.CreateFolderRequested -= x); + }, x => _data.CreateFolderRequested += x, x => _data.CreateFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4093,9 +3593,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeleteFolderRequested += x, x => _data.DeleteFolderRequested -= x); + }, x => _data.DeleteFolderRequested += x, x => _data.DeleteFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4103,9 +3601,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadAttachmentRequested += x, x => _data.DownloadAttachmentRequested -= x); + }, x => _data.DownloadAttachmentRequested += x, x => _data.DownloadAttachmentRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4113,9 +3609,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadMessageRequested += x, x => _data.DownloadMessageRequested -= x); + }, x => _data.DownloadMessageRequested += x, x => _data.DownloadMessageRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4123,9 +3617,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EmptyFolderRequested += x, x => _data.EmptyFolderRequested -= x); + }, x => _data.EmptyFolderRequested += x, x => _data.EmptyFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4133,9 +3625,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4143,9 +3633,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GetAutoReplySettingsRequested += x, x => _data.GetAutoReplySettingsRequested -= x); + }, x => _data.GetAutoReplySettingsRequested += x, x => _data.GetAutoReplySettingsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4153,9 +3641,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MailboxSyncRequested += x, x => _data.MailboxSyncRequested -= x); + }, x => _data.MailboxSyncRequested += x, x => _data.MailboxSyncRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4163,9 +3649,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MoveFolderRequested += x, x => _data.MoveFolderRequested -= x); + }, x => _data.MoveFolderRequested += x, x => _data.MoveFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4173,9 +3657,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4183,9 +3665,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResolveRecipientsRequested += x, x => _data.ResolveRecipientsRequested -= x); + }, x => _data.ResolveRecipientsRequested += x, x => _data.ResolveRecipientsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4193,9 +3673,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4203,9 +3681,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetAutoReplySettingsRequested += x, x => _data.SetAutoReplySettingsRequested -= x); + }, x => _data.SetAutoReplySettingsRequested += x, x => _data.SetAutoReplySettingsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4213,9 +3689,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4223,9 +3697,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValidateCertificatesRequested += x, x => _data.ValidateCertificatesRequested -= x); + }, x => _data.ValidateCertificatesRequested += x, x => _data.ValidateCertificatesRequested -= x); } } @@ -4264,9 +3736,7 @@ namespace Windows.ApplicationModel.ExtendedExecution { void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionRevokedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Revoked += x, x => _data.Revoked -= x); + }, x => _data.Revoked += x, x => _data.Revoked -= x); } } @@ -4305,9 +3775,7 @@ namespace Windows.ApplicationModel.ExtendedExecution.Foreground { void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundRevokedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Revoked += x, x => _data.Revoked -= x); + }, x => _data.Revoked += x, x => _data.Revoked -= x); } } @@ -4350,9 +3818,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Unlocking += x, x => _data.Unlocking -= x); + }, x => _data.Unlocking += x, x => _data.Unlocking -= x); } /// @@ -4377,9 +3843,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AlarmIconChanged += x, x => _data.AlarmIconChanged -= x); + }, x => _data.AlarmIconChanged += x, x => _data.AlarmIconChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4387,9 +3851,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BadgesChanged += x, x => _data.BadgesChanged -= x); + }, x => _data.BadgesChanged += x, x => _data.BadgesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4397,9 +3859,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DetailTextChanged += x, x => _data.DetailTextChanged -= x); + }, x => _data.DetailTextChanged += x, x => _data.DetailTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4407,9 +3867,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LockScreenImageChanged += x, x => _data.LockScreenImageChanged -= x); + }, x => _data.LockScreenImageChanged += x, x => _data.LockScreenImageChanged -= x); } } @@ -4448,9 +3906,7 @@ namespace Windows.ApplicationModel.Resources.Core { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } } @@ -4489,9 +3945,7 @@ namespace Windows.ApplicationModel.Store { void Handler() => eventHandler(global::System.Reactive.Unit.Default); return Handler; - } - - , x => _data.LicenseChanged += x, x => _data.LicenseChanged -= x); + }, x => _data.LicenseChanged += x, x => _data.LicenseChanged -= x); } } @@ -4534,9 +3988,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4544,9 +3996,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -4571,9 +4021,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemCompleted += x, x => _data.ItemCompleted -= x); + }, x => _data.ItemCompleted += x, x => _data.ItemCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4581,9 +4029,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemStatusChanged += x, x => _data.ItemStatusChanged -= x); + }, x => _data.ItemStatusChanged += x, x => _data.ItemStatusChanged -= x); } } @@ -4622,9 +4068,7 @@ namespace Windows.ApplicationModel.UserActivities { void Handler(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserActivityRequested += x, x => _data.UserActivityRequested -= x); + }, x => _data.UserActivityRequested += x, x => _data.UserActivityRequested -= x); } } @@ -4663,9 +4107,7 @@ namespace Windows.ApplicationModel.UserDataAccounts { void Handler(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); } } @@ -4704,9 +4146,7 @@ namespace Windows.ApplicationModel.UserDataTasks { void Handler(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } } @@ -4745,9 +4185,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompleteTaskRequested += x, x => _data.CompleteTaskRequested -= x); + }, x => _data.CompleteTaskRequested += x, x => _data.CompleteTaskRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4755,9 +4193,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateOrUpdateTaskRequested += x, x => _data.CreateOrUpdateTaskRequested -= x); + }, x => _data.CreateOrUpdateTaskRequested += x, x => _data.CreateOrUpdateTaskRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4765,9 +4201,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeleteTaskRequested += x, x => _data.DeleteTaskRequested -= x); + }, x => _data.DeleteTaskRequested += x, x => _data.DeleteTaskRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4775,9 +4209,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SkipOccurrenceRequested += x, x => _data.SkipOccurrenceRequested -= x); + }, x => _data.SkipOccurrenceRequested += x, x => _data.SkipOccurrenceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4785,9 +4217,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); } } @@ -4826,9 +4256,7 @@ namespace Windows.ApplicationModel.VoiceCommands { void Handler(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VoiceCommandCompleted += x, x => _data.VoiceCommandCompleted -= x); + }, x => _data.VoiceCommandCompleted += x, x => _data.VoiceCommandCompleted -= x); } } @@ -4867,9 +4295,7 @@ namespace Windows.ApplicationModel.Wallet.System { void Handler(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); } } @@ -4916,9 +4342,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceptSessionJoinerRequested += x, x => _data.AcceptSessionJoinerRequested -= x); + }, x => _data.AcceptSessionJoinerRequested += x, x => _data.AcceptSessionJoinerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4926,9 +4350,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AuthenticationComplete += x, x => _data.AuthenticationComplete -= x); + }, x => _data.AuthenticationComplete += x, x => _data.AuthenticationComplete -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4936,9 +4358,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CredentialsRequested += x, x => _data.CredentialsRequested -= x); + }, x => _data.CredentialsRequested += x, x => _data.CredentialsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4946,9 +4366,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CredentialsVerificationRequested += x, x => _data.CredentialsVerificationRequested -= x); + }, x => _data.CredentialsVerificationRequested += x, x => _data.CredentialsVerificationRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4956,9 +4374,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionJoined += x, x => _data.SessionJoined -= x); + }, x => _data.SessionJoined += x, x => _data.SessionJoined -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4966,9 +4382,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -4993,9 +4407,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -5020,9 +4432,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Lost += x, x => _data.Lost -= x); + }, x => _data.Lost += x, x => _data.Lost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5030,9 +4440,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MemberAdded += x, x => _data.MemberAdded -= x); + }, x => _data.MemberAdded += x, x => _data.MemberAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5040,9 +4448,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MemberRemoved += x, x => _data.MemberRemoved -= x); + }, x => _data.MemberRemoved += x, x => _data.MemberRemoved -= x); } } @@ -5085,9 +4491,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5095,9 +4499,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NameChanged += x, x => _data.NameChanged -= x); + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5105,9 +4507,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SdpRecordsChanged += x, x => _data.SdpRecordsChanged -= x); + }, x => _data.SdpRecordsChanged += x, x => _data.SdpRecordsChanged -= x); } /// @@ -5132,9 +4532,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5142,9 +4540,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GattServicesChanged += x, x => _data.GattServicesChanged -= x); + }, x => _data.GattServicesChanged += x, x => _data.GattServicesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5152,9 +4548,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NameChanged += x, x => _data.NameChanged -= x); + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); } } @@ -5197,9 +4591,7 @@ namespace Windows.Devices.Bluetooth.Advertisement { void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -5224,9 +4616,7 @@ namespace Windows.Devices.Bluetooth.Advertisement { void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Received += x, x => _data.Received -= x); + }, x => _data.Received += x, x => _data.Received -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5234,9 +4624,7 @@ namespace Windows.Devices.Bluetooth.Advertisement { void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -5303,9 +4691,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -5330,9 +4716,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5340,9 +4724,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SubscribedClientsChanged += x, x => _data.SubscribedClientsChanged -= x); + }, x => _data.SubscribedClientsChanged += x, x => _data.SubscribedClientsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5350,9 +4732,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); } /// @@ -5377,9 +4757,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5387,9 +4765,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); } /// @@ -5414,9 +4790,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -5441,9 +4815,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); } /// @@ -5468,9 +4840,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MaxPduSizeChanged += x, x => _data.MaxPduSizeChanged -= x); + }, x => _data.MaxPduSizeChanged += x, x => _data.MaxPduSizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5478,9 +4848,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); } /// @@ -5505,9 +4873,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MaxNotificationSizeChanged += x, x => _data.MaxNotificationSizeChanged -= x); + }, x => _data.MaxNotificationSizeChanged += x, x => _data.MaxNotificationSizeChanged -= x); } /// @@ -5532,9 +4898,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -5573,9 +4937,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5583,9 +4945,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Disabled += x, x => _data.Disabled -= x); + }, x => _data.Disabled += x, x => _data.Disabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5593,9 +4953,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Enabled += x, x => _data.Enabled -= x); + }, x => _data.Enabled += x, x => _data.Enabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5603,9 +4961,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PathsFailedOrInvalidated += x, x => _data.PathsFailedOrInvalidated -= x); + }, x => _data.PathsFailedOrInvalidated += x, x => _data.PathsFailedOrInvalidated -= x); } } @@ -5656,9 +5012,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessChanged += x, x => _data.AccessChanged -= x); + }, x => _data.AccessChanged += x, x => _data.AccessChanged -= x); } /// @@ -5683,9 +5037,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PairingRequested += x, x => _data.PairingRequested -= x); + }, x => _data.PairingRequested += x, x => _data.PairingRequested -= x); } /// @@ -5710,9 +5062,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DevicePickerDismissed += x, x => _data.DevicePickerDismissed -= x); + }, x => _data.DevicePickerDismissed += x, x => _data.DevicePickerDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5720,9 +5070,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeviceSelected += x, x => _data.DeviceSelected -= x); + }, x => _data.DeviceSelected += x, x => _data.DeviceSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5730,9 +5078,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); } /// @@ -5757,9 +5103,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5767,9 +5111,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5777,9 +5119,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5787,9 +5127,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5797,9 +5135,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -5838,9 +5174,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5848,9 +5182,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5858,9 +5190,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5868,9 +5198,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5878,9 +5206,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -5923,9 +5249,7 @@ namespace Windows.Devices.Geolocation { void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5933,9 +5257,7 @@ namespace Windows.Devices.Geolocation { void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -5960,9 +5282,7 @@ namespace Windows.Devices.Geolocation { void Handler(global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisitStateChanged += x, x => _data.VisitStateChanged -= x); + }, x => _data.VisitStateChanged += x, x => _data.VisitStateChanged -= x); } } @@ -6001,9 +5321,7 @@ namespace Windows.Devices.Geolocation.Geofencing { void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GeofenceStateChanged += x, x => _data.GeofenceStateChanged -= x); + }, x => _data.GeofenceStateChanged += x, x => _data.GeofenceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6011,9 +5329,7 @@ namespace Windows.Devices.Geolocation.Geofencing { void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } } @@ -6052,9 +5368,7 @@ namespace Windows.Devices.HumanInterfaceDevice { void Handler(global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputReportReceived += x, x => _data.InputReportReceived -= x); + }, x => _data.InputReportReceived += x, x => _data.InputReportReceived -= x); } } @@ -6093,9 +5407,7 @@ namespace Windows.Devices.Input { void Handler(global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MouseMoved += x, x => _data.MouseMoved -= x); + }, x => _data.MouseMoved += x, x => _data.MouseMoved -= x); } } @@ -6138,9 +5450,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6148,9 +5458,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6158,9 +5466,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6168,9 +5474,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -6195,9 +5499,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GazeEntered += x, x => _data.GazeEntered -= x); + }, x => _data.GazeEntered += x, x => _data.GazeEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6205,9 +5507,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GazeExited += x, x => _data.GazeExited -= x); + }, x => _data.GazeExited += x, x => _data.GazeExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6215,9 +5515,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GazeMoved += x, x => _data.GazeMoved -= x); + }, x => _data.GazeMoved += x, x => _data.GazeMoved -= x); } } @@ -6256,9 +5554,7 @@ namespace Windows.Devices.Lights { void Handler(global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); + }, x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); } } @@ -6301,9 +5597,7 @@ namespace Windows.Devices.Lights.Effects { void Handler(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); } /// @@ -6328,9 +5622,7 @@ namespace Windows.Devices.Lights.Effects { void Handler(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateRequested += x, x => _data.UpdateRequested -= x); + }, x => _data.UpdateRequested += x, x => _data.UpdateRequested -= x); } } @@ -6369,9 +5661,7 @@ namespace Windows.Devices.Midi { void Handler(global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } } @@ -6446,9 +5736,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -6473,9 +5761,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6483,9 +5769,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6493,9 +5777,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6503,9 +5785,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6513,9 +5793,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); } /// @@ -6540,9 +5818,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6550,9 +5826,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6560,9 +5834,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6570,9 +5842,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -6597,9 +5867,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionControlSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ControlLost += x, x => _data.ControlLost -= x); + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); } /// @@ -6624,9 +5892,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -6651,9 +5917,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6661,9 +5925,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6671,9 +5933,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6681,9 +5941,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6691,9 +5949,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); } /// @@ -6718,9 +5974,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6728,9 +5982,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6738,9 +5990,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6748,9 +5998,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -6775,9 +6023,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -6802,9 +6048,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6812,9 +6056,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6822,9 +6064,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6832,9 +6072,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6842,9 +6080,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); } /// @@ -6869,9 +6105,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6879,9 +6113,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6889,9 +6121,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6899,9 +6129,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -6980,9 +6208,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -7007,9 +6233,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -7034,9 +6258,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AlarmTimeoutExpired += x, x => _data.AlarmTimeoutExpired -= x); + }, x => _data.AlarmTimeoutExpired += x, x => _data.AlarmTimeoutExpired -= x); } /// @@ -7061,9 +6283,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); + }, x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7071,9 +6291,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); + }, x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); } /// @@ -7098,9 +6316,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7108,9 +6324,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7118,9 +6332,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7128,9 +6340,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ImagePreviewReceived += x, x => _data.ImagePreviewReceived -= x); + }, x => _data.ImagePreviewReceived += x, x => _data.ImagePreviewReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7138,9 +6348,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7148,9 +6356,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); return Handler; - } - - , x => _data.TriggerPressed += x, x => _data.TriggerPressed -= x); + }, x => _data.TriggerPressed += x, x => _data.TriggerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7158,9 +6364,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); return Handler; - } - - , x => _data.TriggerReleased += x, x => _data.TriggerReleased -= x); + }, x => _data.TriggerReleased += x, x => _data.TriggerReleased -= x); } /// @@ -7185,9 +6389,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7195,9 +6397,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); } /// @@ -7222,9 +6422,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7232,9 +6430,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7242,9 +6438,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -7269,9 +6463,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AamvaCardDataReceived += x, x => _data.AamvaCardDataReceived -= x); + }, x => _data.AamvaCardDataReceived += x, x => _data.AamvaCardDataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7279,9 +6471,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BankCardDataReceived += x, x => _data.BankCardDataReceived -= x); + }, x => _data.BankCardDataReceived += x, x => _data.BankCardDataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7289,9 +6479,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7299,9 +6487,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7309,9 +6495,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader e) => eventHandler(e); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7319,9 +6503,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VendorSpecificDataReceived += x, x => _data.VendorSpecificDataReceived -= x); + }, x => _data.VendorSpecificDataReceived += x, x => _data.VendorSpecificDataReceived -= x); } /// @@ -7346,9 +6528,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7356,9 +6536,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); } /// @@ -7383,9 +6561,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -7410,9 +6586,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } } @@ -7455,9 +6629,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -7482,9 +6654,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisableScannerRequested += x, x => _data.DisableScannerRequested -= x); + }, x => _data.DisableScannerRequested += x, x => _data.DisableScannerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7492,9 +6662,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnableScannerRequested += x, x => _data.EnableScannerRequested -= x); + }, x => _data.EnableScannerRequested += x, x => _data.EnableScannerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7502,9 +6670,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GetBarcodeSymbologyAttributesRequested += x, x => _data.GetBarcodeSymbologyAttributesRequested -= x); + }, x => _data.GetBarcodeSymbologyAttributesRequested += x, x => _data.GetBarcodeSymbologyAttributesRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7512,9 +6678,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HideVideoPreviewRequested += x, x => _data.HideVideoPreviewRequested -= x); + }, x => _data.HideVideoPreviewRequested += x, x => _data.HideVideoPreviewRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7522,9 +6686,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetActiveSymbologiesRequested += x, x => _data.SetActiveSymbologiesRequested -= x); + }, x => _data.SetActiveSymbologiesRequested += x, x => _data.SetActiveSymbologiesRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7532,9 +6694,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetBarcodeSymbologyAttributesRequested += x, x => _data.SetBarcodeSymbologyAttributesRequested -= x); + }, x => _data.SetBarcodeSymbologyAttributesRequested += x, x => _data.SetBarcodeSymbologyAttributesRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7542,9 +6702,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StartSoftwareTriggerRequested += x, x => _data.StartSoftwareTriggerRequested -= x); + }, x => _data.StartSoftwareTriggerRequested += x, x => _data.StartSoftwareTriggerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7552,9 +6710,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StopSoftwareTriggerRequested += x, x => _data.StopSoftwareTriggerRequested -= x); + }, x => _data.StopSoftwareTriggerRequested += x, x => _data.StopSoftwareTriggerRequested -= x); } } @@ -7593,9 +6749,7 @@ namespace Windows.Devices.Power { void Handler(global::Windows.Devices.Power.Battery sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReportUpdated += x, x => _data.ReportUpdated -= x); + }, x => _data.ReportUpdated += x, x => _data.ReportUpdated -= x); } } @@ -7634,9 +6788,7 @@ namespace Windows.Devices.Printers.Extensions { void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrinterChanged += x, x => _data.PrinterChanged -= x); + }, x => _data.PrinterChanged += x, x => _data.PrinterChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7644,9 +6796,7 @@ namespace Windows.Devices.Printers.Extensions { void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrintRequested += x, x => _data.PrintRequested -= x); + }, x => _data.PrintRequested += x, x => _data.PrintRequested -= x); } } @@ -7685,9 +6835,7 @@ namespace Windows.Devices.Radios { void Handler(global::Windows.Devices.Radios.Radio sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -7778,9 +6926,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7788,9 +6934,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Shaken += x, x => _data.Shaken -= x); + }, x => _data.Shaken += x, x => _data.Shaken -= x); } /// @@ -7815,9 +6959,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -7842,9 +6984,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -7869,9 +7009,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -7896,9 +7034,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -7923,9 +7059,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -7950,9 +7084,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -7977,9 +7109,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -8004,9 +7134,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -8031,9 +7159,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -8058,9 +7184,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -8085,9 +7209,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -8112,9 +7234,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -8139,9 +7259,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); } } @@ -8180,9 +7298,7 @@ namespace Windows.Devices.Sensors.Custom { void Handler(global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } } @@ -8221,9 +7337,7 @@ namespace Windows.Devices.SerialCommunication { void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorReceived += x, x => _data.ErrorReceived -= x); + }, x => _data.ErrorReceived += x, x => _data.ErrorReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8231,9 +7345,7 @@ namespace Windows.Devices.SerialCommunication { void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PinChanged += x, x => _data.PinChanged -= x); + }, x => _data.PinChanged += x, x => _data.PinChanged -= x); } } @@ -8272,9 +7384,7 @@ namespace Windows.Devices.SmartCards { void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CardAdded += x, x => _data.CardAdded -= x); + }, x => _data.CardAdded += x, x => _data.CardAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8282,9 +7392,7 @@ namespace Windows.Devices.SmartCards { void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CardRemoved += x, x => _data.CardRemoved -= x); + }, x => _data.CardRemoved += x, x => _data.CardRemoved -= x); } } @@ -8327,9 +7435,7 @@ namespace Windows.Devices.Sms { void Handler(global::Windows.Devices.Sms.SmsDevice2 sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeviceStatusChanged += x, x => _data.DeviceStatusChanged -= x); + }, x => _data.DeviceStatusChanged += x, x => _data.DeviceStatusChanged -= x); } /// @@ -8354,9 +7460,7 @@ namespace Windows.Devices.Sms { void Handler(global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } } @@ -8395,9 +7499,7 @@ namespace Windows.Devices.Usb { void Handler(global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); } } @@ -8436,9 +7538,7 @@ namespace Windows.Devices.WiFi { void Handler(global::Windows.Devices.WiFi.WiFiAdapter sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableNetworksChanged += x, x => _data.AvailableNetworksChanged -= x); + }, x => _data.AvailableNetworksChanged += x, x => _data.AvailableNetworksChanged -= x); } } @@ -8485,9 +7585,7 @@ namespace Windows.Devices.WiFiDirect { void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -8512,9 +7610,7 @@ namespace Windows.Devices.WiFiDirect { void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); + }, x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); } /// @@ -8539,9 +7635,7 @@ namespace Windows.Devices.WiFiDirect { void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); } } @@ -8588,9 +7682,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionDeferred += x, x => _data.SessionDeferred -= x); + }, x => _data.SessionDeferred += x, x => _data.SessionDeferred -= x); } /// @@ -8615,9 +7707,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8625,9 +7715,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutoAcceptSessionConnected += x, x => _data.AutoAcceptSessionConnected -= x); + }, x => _data.AutoAcceptSessionConnected += x, x => _data.AutoAcceptSessionConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8635,9 +7723,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionRequested += x, x => _data.SessionRequested -= x); + }, x => _data.SessionRequested += x, x => _data.SessionRequested -= x); } /// @@ -8662,9 +7748,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemotePortAdded += x, x => _data.RemotePortAdded -= x); + }, x => _data.RemotePortAdded += x, x => _data.RemotePortAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8672,9 +7756,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); } } @@ -8713,9 +7795,7 @@ namespace Windows.Foundation { void Handler(global::Windows.Foundation.IMemoryBufferReference sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } } @@ -8762,9 +7842,7 @@ namespace Windows.Foundation.Collections { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -8789,9 +7867,7 @@ namespace Windows.Foundation.Collections { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -8816,9 +7892,7 @@ namespace Windows.Foundation.Collections { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } } @@ -8869,9 +7943,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); } /// @@ -8896,9 +7968,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); } /// @@ -8923,9 +7993,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); } /// @@ -8950,9 +8018,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); } } @@ -9015,9 +8081,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9025,9 +8089,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9035,9 +8097,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -9062,9 +8122,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9072,9 +8130,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9082,9 +8138,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -9109,9 +8163,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9119,9 +8171,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9129,9 +8179,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -9156,9 +8204,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9166,9 +8212,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9176,9 +8220,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -9203,9 +8245,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9213,9 +8253,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9223,9 +8261,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -9250,9 +8286,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9260,9 +8294,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9270,9 +8302,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -9297,9 +8327,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9307,9 +8335,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9317,9 +8343,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } } @@ -9362,9 +8386,7 @@ namespace Windows.Graphics.Capture { void Handler(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -9389,9 +8411,7 @@ namespace Windows.Graphics.Capture { void Handler(global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } } @@ -9438,9 +8458,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BrightnessLevelChanged += x, x => _data.BrightnessLevelChanged -= x); + }, x => _data.BrightnessLevelChanged += x, x => _data.BrightnessLevelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9448,9 +8466,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9458,9 +8474,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); + }, x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); } /// @@ -9485,9 +8499,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CanOverrideChanged += x, x => _data.CanOverrideChanged -= x); + }, x => _data.CanOverrideChanged += x, x => _data.CanOverrideChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9495,9 +8507,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisplayEnhancementOverrideCapabilitiesChanged += x, x => _data.DisplayEnhancementOverrideCapabilitiesChanged -= x); + }, x => _data.DisplayEnhancementOverrideCapabilitiesChanged += x, x => _data.DisplayEnhancementOverrideCapabilitiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9505,9 +8515,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); } /// @@ -9532,9 +8540,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvancedColorInfoChanged += x, x => _data.AdvancedColorInfoChanged -= x); + }, x => _data.AdvancedColorInfoChanged += x, x => _data.AdvancedColorInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9542,9 +8548,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorProfileChanged += x, x => _data.ColorProfileChanged -= x); + }, x => _data.ColorProfileChanged += x, x => _data.ColorProfileChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9552,9 +8556,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9562,9 +8564,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9572,9 +8572,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StereoEnabledChanged += x, x => _data.StereoEnabledChanged -= x); + }, x => _data.StereoEnabledChanged += x, x => _data.StereoEnabledChanged -= x); } } @@ -9613,9 +8611,7 @@ namespace Windows.Graphics.Display.Core { void Handler(global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisplayModesChanged += x, x => _data.DisplayModesChanged -= x); + }, x => _data.DisplayModesChanged += x, x => _data.DisplayModesChanged -= x); } } @@ -9654,9 +8650,7 @@ namespace Windows.Graphics.Holographic { void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraAdded += x, x => _data.CameraAdded -= x); + }, x => _data.CameraAdded += x, x => _data.CameraAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9664,9 +8658,7 @@ namespace Windows.Graphics.Holographic { void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraRemoved += x, x => _data.CameraRemoved -= x); + }, x => _data.CameraRemoved += x, x => _data.CameraRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9674,9 +8666,7 @@ namespace Windows.Graphics.Holographic { void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserPresenceChanged += x, x => _data.UserPresenceChanged -= x); + }, x => _data.UserPresenceChanged += x, x => _data.UserPresenceChanged -= x); } } @@ -9719,9 +8709,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrintTaskRequested += x, x => _data.PrintTaskRequested -= x); + }, x => _data.PrintTaskRequested += x, x => _data.PrintTaskRequested -= x); } /// @@ -9746,9 +8734,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9756,9 +8742,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Previewing += x, x => _data.Previewing -= x); + }, x => _data.Previewing += x, x => _data.Previewing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9766,9 +8750,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Progressing += x, x => _data.Progressing -= x); + }, x => _data.Progressing += x, x => _data.Progressing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9776,9 +8758,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Submitting += x, x => _data.Submitting -= x); + }, x => _data.Submitting += x, x => _data.Submitting -= x); } } @@ -9817,9 +8797,7 @@ namespace Windows.Graphics.Printing.OptionDetails { void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BeginValidation += x, x => _data.BeginValidation -= x); + }, x => _data.BeginValidation += x, x => _data.BeginValidation -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9827,9 +8805,7 @@ namespace Windows.Graphics.Printing.OptionDetails { void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionChanged += x, x => _data.OptionChanged -= x); + }, x => _data.OptionChanged += x, x => _data.OptionChanged -= x); } } @@ -9872,9 +8848,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9882,9 +8856,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Submitted += x, x => _data.Submitted -= x); + }, x => _data.Submitted += x, x => _data.Submitted -= x); } /// @@ -9909,9 +8881,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9919,9 +8889,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.XpsDataAvailable += x, x => _data.XpsDataAvailable -= x); + }, x => _data.XpsDataAvailable += x, x => _data.XpsDataAvailable -= x); } } @@ -9960,9 +8928,7 @@ namespace Windows.Management.Policies { void Handler(global::Windows.Management.Policies.NamedPolicyData sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } } @@ -10005,9 +8971,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Ended += x, x => _data.Ended -= x); + }, x => _data.Ended += x, x => _data.Ended -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10015,9 +8979,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Failed += x, x => _data.Failed -= x); + }, x => _data.Failed += x, x => _data.Failed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10025,9 +8987,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10035,9 +8995,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -10062,9 +9020,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutoRepeatModeChangeRequested += x, x => _data.AutoRepeatModeChangeRequested -= x); + }, x => _data.AutoRepeatModeChangeRequested += x, x => _data.AutoRepeatModeChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10072,9 +9028,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10082,9 +9036,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackPositionChangeRequested += x, x => _data.PlaybackPositionChangeRequested -= x); + }, x => _data.PlaybackPositionChangeRequested += x, x => _data.PlaybackPositionChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10092,9 +9044,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10102,9 +9052,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10112,9 +9060,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShuffleEnabledChangeRequested += x, x => _data.ShuffleEnabledChangeRequested -= x); + }, x => _data.ShuffleEnabledChangeRequested += x, x => _data.ShuffleEnabledChangeRequested -= x); } } @@ -10173,9 +9119,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioFileInputNode sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileCompleted += x, x => _data.FileCompleted -= x); + }, x => _data.FileCompleted += x, x => _data.FileCompleted -= x); } /// @@ -10200,9 +9144,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioFrameCompleted += x, x => _data.AudioFrameCompleted -= x); + }, x => _data.AudioFrameCompleted += x, x => _data.AudioFrameCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10210,9 +9152,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); } /// @@ -10237,9 +9177,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuantumProcessed += x, x => _data.QuantumProcessed -= x); + }, x => _data.QuantumProcessed += x, x => _data.QuantumProcessed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10247,9 +9185,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10257,9 +9193,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnrecoverableErrorOccurred += x, x => _data.UnrecoverableErrorOccurred -= x); + }, x => _data.UnrecoverableErrorOccurred += x, x => _data.UnrecoverableErrorOccurred -= x); } /// @@ -10284,9 +9218,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioStateMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SoundLevelChanged += x, x => _data.SoundLevelChanged -= x); + }, x => _data.SoundLevelChanged += x, x => _data.SoundLevelChanged -= x); } /// @@ -10311,9 +9243,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaSourceCompleted += x, x => _data.MediaSourceCompleted -= x); + }, x => _data.MediaSourceCompleted += x, x => _data.MediaSourceCompleted -= x); } /// @@ -10338,9 +9268,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } } @@ -10395,9 +9323,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AllPhotosCaptured += x, x => _data.AllPhotosCaptured -= x); + }, x => _data.AllPhotosCaptured += x, x => _data.AllPhotosCaptured -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10405,9 +9331,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionalReferencePhotoCaptured += x, x => _data.OptionalReferencePhotoCaptured -= x); + }, x => _data.OptionalReferencePhotoCaptured += x, x => _data.OptionalReferencePhotoCaptured -= x); } /// @@ -10432,9 +9356,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.AppCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CapturingChanged += x, x => _data.CapturingChanged -= x); + }, x => _data.CapturingChanged += x, x => _data.CapturingChanged -= x); } /// @@ -10459,9 +9381,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); } /// @@ -10486,9 +9406,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraStreamStateChanged += x, x => _data.CameraStreamStateChanged -= x); + }, x => _data.CameraStreamStateChanged += x, x => _data.CameraStreamStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10496,9 +9414,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CaptureDeviceExclusiveControlStatusChanged += x, x => _data.CaptureDeviceExclusiveControlStatusChanged -= x); + }, x => _data.CaptureDeviceExclusiveControlStatusChanged += x, x => _data.CaptureDeviceExclusiveControlStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10506,9 +9422,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFailedEventArgs errorEventArgs) => eventHandler((sender, errorEventArgs)); return Handler; - } - - , x => _data.Failed += x, x => _data.Failed -= x); + }, x => _data.Failed += x, x => _data.Failed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10516,9 +9430,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusChanged += x, x => _data.FocusChanged -= x); + }, x => _data.FocusChanged += x, x => _data.FocusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10526,9 +9438,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PhotoConfirmationCaptured += x, x => _data.PhotoConfirmationCaptured -= x); + }, x => _data.PhotoConfirmationCaptured += x, x => _data.PhotoConfirmationCaptured -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10536,9 +9446,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender) => eventHandler(sender); return Handler; - } - - , x => _data.RecordLimitationExceeded += x, x => _data.RecordLimitationExceeded -= x); + }, x => _data.RecordLimitationExceeded += x, x => _data.RecordLimitationExceeded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10546,9 +9454,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThermalStatusChanged += x, x => _data.ThermalStatusChanged -= x); + }, x => _data.ThermalStatusChanged += x, x => _data.ThermalStatusChanged -= x); } /// @@ -10573,9 +9479,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceSuspensionChanged += x, x => _data.SourceSuspensionChanged -= x); + }, x => _data.SourceSuspensionChanged += x, x => _data.SourceSuspensionChanged -= x); } } @@ -10614,9 +9518,7 @@ namespace Windows.Media.Capture.Core { void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10624,9 +9526,7 @@ namespace Windows.Media.Capture.Core { void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -10673,9 +9573,7 @@ namespace Windows.Media.Capture.Frames { void Handler(global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -10700,9 +9598,7 @@ namespace Windows.Media.Capture.Frames { void Handler(global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); } /// @@ -10727,9 +9623,7 @@ namespace Windows.Media.Capture.Frames { void Handler(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } } @@ -10772,9 +9666,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10782,9 +9674,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingConnection sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -10809,9 +9699,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CastingDevicePickerDismissed += x, x => _data.CastingDevicePickerDismissed -= x); + }, x => _data.CastingDevicePickerDismissed += x, x => _data.CastingDevicePickerDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10819,9 +9707,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CastingDeviceSelected += x, x => _data.CastingDeviceSelected -= x); + }, x => _data.CastingDeviceSelected += x, x => _data.CastingDeviceSelected -= x); } } @@ -10860,9 +9746,7 @@ namespace Windows.Media.ContentRestrictions { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.RestrictionsChanged += x, x => _data.RestrictionsChanged -= x); + }, x => _data.RestrictionsChanged += x, x => _data.RestrictionsChanged -= x); } } @@ -10905,9 +9789,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaPropertiesChanged += x, x => _data.MediaPropertiesChanged -= x); + }, x => _data.MediaPropertiesChanged += x, x => _data.MediaPropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10915,9 +9797,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackInfoChanged += x, x => _data.PlaybackInfoChanged -= x); + }, x => _data.PlaybackInfoChanged += x, x => _data.PlaybackInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10925,9 +9805,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimelinePropertiesChanged += x, x => _data.TimelinePropertiesChanged -= x); + }, x => _data.TimelinePropertiesChanged += x, x => _data.TimelinePropertiesChanged -= x); } /// @@ -10952,9 +9830,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentSessionChanged += x, x => _data.CurrentSessionChanged -= x); + }, x => _data.CurrentSessionChanged += x, x => _data.CurrentSessionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10962,9 +9838,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionsChanged += x, x => _data.SessionsChanged -= x); + }, x => _data.SessionsChanged += x, x => _data.SessionsChanged -= x); } } @@ -11067,9 +9941,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); } /// @@ -11094,9 +9966,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FaceDetected += x, x => _data.FaceDetected -= x); + }, x => _data.FaceDetected += x, x => _data.FaceDetected -= x); } /// @@ -11121,9 +9991,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -11148,9 +10016,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Binding += x, x => _data.Binding -= x); + }, x => _data.Binding += x, x => _data.Binding -= x); } /// @@ -11175,9 +10041,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaBindingEventArgs sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); } /// @@ -11202,9 +10066,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenOperationCompleted += x, x => _data.OpenOperationCompleted -= x); + }, x => _data.OpenOperationCompleted += x, x => _data.OpenOperationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11212,9 +10074,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -11239,9 +10099,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InitializeMediaStreamSourceRequested += x, x => _data.InitializeMediaStreamSourceRequested -= x); + }, x => _data.InitializeMediaStreamSourceRequested += x, x => _data.InitializeMediaStreamSourceRequested -= x); } /// @@ -11266,9 +10124,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSample sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Processed += x, x => _data.Processed -= x); + }, x => _data.Processed += x, x => _data.Processed -= x); } /// @@ -11293,9 +10149,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11303,9 +10157,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Paused += x, x => _data.Paused -= x); + }, x => _data.Paused += x, x => _data.Paused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11313,9 +10165,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SampleRendered += x, x => _data.SampleRendered -= x); + }, x => _data.SampleRendered += x, x => _data.SampleRendered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11323,9 +10173,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SampleRequested += x, x => _data.SampleRequested -= x); + }, x => _data.SampleRequested += x, x => _data.SampleRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11333,9 +10181,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Starting += x, x => _data.Starting -= x); + }, x => _data.Starting += x, x => _data.Starting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11343,9 +10189,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SwitchStreamsRequested += x, x => _data.SwitchStreamsRequested -= x); + }, x => _data.SwitchStreamsRequested += x, x => _data.SwitchStreamsRequested -= x); } /// @@ -11370,9 +10214,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Aborted += x, x => _data.Aborted -= x); + }, x => _data.Aborted += x, x => _data.Aborted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11380,9 +10222,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11390,9 +10230,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11400,9 +10238,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateEnded += x, x => _data.UpdateEnded -= x); + }, x => _data.UpdateEnded += x, x => _data.UpdateEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11410,9 +10246,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateStarting += x, x => _data.UpdateStarting -= x); + }, x => _data.UpdateStarting += x, x => _data.UpdateStarting -= x); } /// @@ -11437,9 +10271,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceBufferAdded += x, x => _data.SourceBufferAdded -= x); + }, x => _data.SourceBufferAdded += x, x => _data.SourceBufferAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11447,9 +10279,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceBufferRemoved += x, x => _data.SourceBufferRemoved -= x); + }, x => _data.SourceBufferRemoved += x, x => _data.SourceBufferRemoved -= x); } /// @@ -11474,9 +10304,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11484,9 +10312,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Ended += x, x => _data.Ended -= x); + }, x => _data.Ended += x, x => _data.Ended -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11494,9 +10320,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -11521,9 +10345,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SceneAnalyzed += x, x => _data.SceneAnalyzed -= x); + }, x => _data.SceneAnalyzed += x, x => _data.SceneAnalyzed -= x); } /// @@ -11548,9 +10370,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CueEntered += x, x => _data.CueEntered -= x); + }, x => _data.CueEntered += x, x => _data.CueEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11558,9 +10378,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CueExited += x, x => _data.CueExited -= x); + }, x => _data.CueExited += x, x => _data.CueExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11568,9 +10386,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TrackFailed += x, x => _data.TrackFailed -= x); + }, x => _data.TrackFailed += x, x => _data.TrackFailed -= x); } /// @@ -11595,9 +10411,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Resolved += x, x => _data.Resolved -= x); + }, x => _data.Resolved += x, x => _data.Resolved -= x); } /// @@ -11622,9 +10436,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); } /// @@ -11649,9 +10461,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); } } @@ -11690,9 +10500,7 @@ namespace Windows.Media.Devices { void Handler(global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ModuleNotificationReceived += x, x => _data.ModuleNotificationReceived -= x); + }, x => _data.ModuleNotificationReceived += x, x => _data.ModuleNotificationReceived -= x); } } @@ -11731,9 +10539,7 @@ namespace Windows.Media.DialProtocol { void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DialDevicePickerDismissed += x, x => _data.DialDevicePickerDismissed -= x); + }, x => _data.DialDevicePickerDismissed += x, x => _data.DialDevicePickerDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11741,9 +10547,7 @@ namespace Windows.Media.DialProtocol { void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DialDeviceSelected += x, x => _data.DialDeviceSelected -= x); + }, x => _data.DialDeviceSelected += x, x => _data.DialDeviceSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11751,9 +10555,7 @@ namespace Windows.Media.DialProtocol { void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); } } @@ -11796,9 +10598,7 @@ namespace Windows.Media.Effects { void Handler(global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioCaptureEffectsChanged += x, x => _data.AudioCaptureEffectsChanged -= x); + }, x => _data.AudioCaptureEffectsChanged += x, x => _data.AudioCaptureEffectsChanged -= x); } /// @@ -11823,9 +10623,7 @@ namespace Windows.Media.Effects { void Handler(global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioRenderEffectsChanged += x, x => _data.AudioRenderEffectsChanged -= x); + }, x => _data.AudioRenderEffectsChanged += x, x => _data.AudioRenderEffectsChanged -= x); } } @@ -11864,9 +10662,7 @@ namespace Windows.Media.Import { void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemImported += x, x => _data.ItemImported -= x); + }, x => _data.ItemImported += x, x => _data.ItemImported -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11874,9 +10670,7 @@ namespace Windows.Media.Import { void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } } @@ -11955,9 +10749,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreakEnded += x, x => _data.BreakEnded -= x); + }, x => _data.BreakEnded += x, x => _data.BreakEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11965,9 +10757,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreakSkipped += x, x => _data.BreakSkipped -= x); + }, x => _data.BreakSkipped += x, x => _data.BreakSkipped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11975,9 +10765,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreaksSeekedOver += x, x => _data.BreaksSeekedOver -= x); + }, x => _data.BreaksSeekedOver += x, x => _data.BreaksSeekedOver -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11985,9 +10773,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreakStarted += x, x => _data.BreakStarted -= x); + }, x => _data.BreakStarted += x, x => _data.BreakStarted -= x); } /// @@ -12012,9 +10798,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakSchedule sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScheduleChanged += x, x => _data.ScheduleChanged -= x); + }, x => _data.ScheduleChanged += x, x => _data.ScheduleChanged -= x); } /// @@ -12039,9 +10823,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -12066,9 +10848,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutoRepeatModeReceived += x, x => _data.AutoRepeatModeReceived -= x); + }, x => _data.AutoRepeatModeReceived += x, x => _data.AutoRepeatModeReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12076,9 +10856,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FastForwardReceived += x, x => _data.FastForwardReceived -= x); + }, x => _data.FastForwardReceived += x, x => _data.FastForwardReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12086,9 +10864,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NextReceived += x, x => _data.NextReceived -= x); + }, x => _data.NextReceived += x, x => _data.NextReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12096,9 +10872,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PauseReceived += x, x => _data.PauseReceived -= x); + }, x => _data.PauseReceived += x, x => _data.PauseReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12106,9 +10880,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlayReceived += x, x => _data.PlayReceived -= x); + }, x => _data.PlayReceived += x, x => _data.PlayReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12116,9 +10888,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionReceived += x, x => _data.PositionReceived -= x); + }, x => _data.PositionReceived += x, x => _data.PositionReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12126,9 +10896,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PreviousReceived += x, x => _data.PreviousReceived -= x); + }, x => _data.PreviousReceived += x, x => _data.PreviousReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12136,9 +10904,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RateReceived += x, x => _data.RateReceived -= x); + }, x => _data.RateReceived += x, x => _data.RateReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12146,9 +10912,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RewindReceived += x, x => _data.RewindReceived -= x); + }, x => _data.RewindReceived += x, x => _data.RewindReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12156,9 +10920,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShuffleReceived += x, x => _data.ShuffleReceived -= x); + }, x => _data.ShuffleReceived += x, x => _data.ShuffleReceived -= x); } /// @@ -12183,9 +10945,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); } /// @@ -12210,9 +10970,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioTracksChanged += x, x => _data.AudioTracksChanged -= x); + }, x => _data.AudioTracksChanged += x, x => _data.AudioTracksChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12220,9 +10978,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimedMetadataTracksChanged += x, x => _data.TimedMetadataTracksChanged -= x); + }, x => _data.TimedMetadataTracksChanged += x, x => _data.TimedMetadataTracksChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12230,9 +10986,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoTracksChanged += x, x => _data.VideoTracksChanged -= x); + }, x => _data.VideoTracksChanged += x, x => _data.VideoTracksChanged -= x); } /// @@ -12257,9 +11011,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12267,9 +11019,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemFailed += x, x => _data.ItemFailed -= x); + }, x => _data.ItemFailed += x, x => _data.ItemFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12277,9 +11027,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemOpened += x, x => _data.ItemOpened -= x); + }, x => _data.ItemOpened += x, x => _data.ItemOpened -= x); } /// @@ -12304,9 +11052,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferedRangesChanged += x, x => _data.BufferedRangesChanged -= x); + }, x => _data.BufferedRangesChanged += x, x => _data.BufferedRangesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12314,9 +11060,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12324,9 +11068,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12334,9 +11076,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12344,9 +11084,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12354,9 +11092,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NaturalDurationChanged += x, x => _data.NaturalDurationChanged -= x); + }, x => _data.NaturalDurationChanged += x, x => _data.NaturalDurationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12364,9 +11100,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NaturalVideoSizeChanged += x, x => _data.NaturalVideoSizeChanged -= x); + }, x => _data.NaturalVideoSizeChanged += x, x => _data.NaturalVideoSizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12374,9 +11108,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackRateChanged += x, x => _data.PlaybackRateChanged -= x); + }, x => _data.PlaybackRateChanged += x, x => _data.PlaybackRateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12384,9 +11116,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackStateChanged += x, x => _data.PlaybackStateChanged -= x); + }, x => _data.PlaybackStateChanged += x, x => _data.PlaybackStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12394,9 +11124,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlayedRangesChanged += x, x => _data.PlayedRangesChanged -= x); + }, x => _data.PlayedRangesChanged += x, x => _data.PlayedRangesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12404,9 +11132,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12414,9 +11140,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeekableRangesChanged += x, x => _data.SeekableRangesChanged -= x); + }, x => _data.SeekableRangesChanged += x, x => _data.SeekableRangesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12424,9 +11148,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12434,9 +11156,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SupportedPlaybackRatesChanged += x, x => _data.SupportedPlaybackRatesChanged -= x); + }, x => _data.SupportedPlaybackRatesChanged += x, x => _data.SupportedPlaybackRatesChanged -= x); } /// @@ -12461,9 +11181,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PresentationModeChanged += x, x => _data.PresentationModeChanged -= x); + }, x => _data.PresentationModeChanged += x, x => _data.PresentationModeChanged -= x); } /// @@ -12488,9 +11206,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -12515,9 +11231,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12525,9 +11239,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12535,9 +11247,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12545,9 +11255,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsMutedChanged += x, x => _data.IsMutedChanged -= x); + }, x => _data.IsMutedChanged += x, x => _data.IsMutedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12555,9 +11263,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12565,9 +11271,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12575,9 +11279,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12585,9 +11287,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaPlayerRateChanged += x, x => _data.MediaPlayerRateChanged -= x); + }, x => _data.MediaPlayerRateChanged += x, x => _data.MediaPlayerRateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12595,9 +11295,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackMediaMarkerReached += x, x => _data.PlaybackMediaMarkerReached -= x); + }, x => _data.PlaybackMediaMarkerReached += x, x => _data.PlaybackMediaMarkerReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12605,9 +11303,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12615,9 +11311,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceChanged += x, x => _data.SourceChanged -= x); + }, x => _data.SourceChanged += x, x => _data.SourceChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12625,9 +11319,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SubtitleFrameChanged += x, x => _data.SubtitleFrameChanged -= x); + }, x => _data.SubtitleFrameChanged += x, x => _data.SubtitleFrameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12635,9 +11327,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoFrameAvailable += x, x => _data.VideoFrameAvailable -= x); + }, x => _data.VideoFrameAvailable += x, x => _data.VideoFrameAvailable -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12645,9 +11335,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, double args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoRatioChanged += x, x => _data.VideoRatioChanged -= x); + }, x => _data.VideoRatioChanged += x, x => _data.VideoRatioChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12655,9 +11343,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); } } @@ -12704,9 +11390,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Error += x, x => _data.Error -= x); + }, x => _data.Error += x, x => _data.Error -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12714,9 +11398,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12724,9 +11406,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Transferred += x, x => _data.Transferred -= x); + }, x => _data.Transferred += x, x => _data.Transferred -= x); } /// @@ -12751,9 +11431,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRequested += x, x => _data.SourceRequested -= x); + }, x => _data.SourceRequested += x, x => _data.SourceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12761,9 +11439,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceSelected += x, x => _data.SourceSelected -= x); + }, x => _data.SourceSelected += x, x => _data.SourceSelected -= x); } /// @@ -12788,9 +11464,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentTimeChangeRequested += x, x => _data.CurrentTimeChangeRequested -= x); + }, x => _data.CurrentTimeChangeRequested += x, x => _data.CurrentTimeChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12798,9 +11472,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MuteChangeRequested += x, x => _data.MuteChangeRequested -= x); + }, x => _data.MuteChangeRequested += x, x => _data.MuteChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12808,9 +11480,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PauseRequested += x, x => _data.PauseRequested -= x); + }, x => _data.PauseRequested += x, x => _data.PauseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12818,9 +11488,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12828,9 +11496,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlayRequested += x, x => _data.PlayRequested -= x); + }, x => _data.PlayRequested += x, x => _data.PlayRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12838,9 +11504,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceChangeRequested += x, x => _data.SourceChangeRequested -= x); + }, x => _data.SourceChangeRequested += x, x => _data.SourceChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12848,9 +11512,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StopRequested += x, x => _data.StopRequested -= x); + }, x => _data.StopRequested += x, x => _data.StopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12858,9 +11520,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimeUpdateRequested += x, x => _data.TimeUpdateRequested -= x); + }, x => _data.TimeUpdateRequested += x, x => _data.TimeUpdateRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12868,9 +11528,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VolumeChangeRequested += x, x => _data.VolumeChangeRequested -= x); + }, x => _data.VolumeChangeRequested += x, x => _data.VolumeChangeRequested -= x); } } @@ -12913,9 +11571,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.HdcpSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProtectionChanged += x, x => _data.ProtectionChanged -= x); + }, x => _data.ProtectionChanged += x, x => _data.ProtectionChanged -= x); } /// @@ -12940,9 +11596,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ComponentLoadFailedEventArgs e) => eventHandler((sender, e)); return Handler; - } - - , x => _data.ComponentLoadFailed += x, x => _data.ComponentLoadFailed -= x); + }, x => _data.ComponentLoadFailed += x, x => _data.ComponentLoadFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12950,9 +11604,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.MediaProtectionManager sender) => eventHandler(sender); return Handler; - } - - , x => _data.RebootNeeded += x, x => _data.RebootNeeded -= x); + }, x => _data.RebootNeeded += x, x => _data.RebootNeeded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12960,9 +11612,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ServiceRequestedEventArgs e) => eventHandler((sender, e)); return Handler; - } - - , x => _data.ServiceRequested += x, x => _data.ServiceRequested -= x); + }, x => _data.ServiceRequested += x, x => _data.ServiceRequested -= x); } } @@ -13001,9 +11651,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ClosedCaptionDataReceived += x, x => _data.ClosedCaptionDataReceived -= x); + }, x => _data.ClosedCaptionDataReceived += x, x => _data.ClosedCaptionDataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13011,9 +11659,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LicenseFetchCompleted += x, x => _data.LicenseFetchCompleted -= x); + }, x => _data.LicenseFetchCompleted += x, x => _data.LicenseFetchCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13021,9 +11667,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProximityDetectionCompleted += x, x => _data.ProximityDetectionCompleted -= x); + }, x => _data.ProximityDetectionCompleted += x, x => _data.ProximityDetectionCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13031,9 +11675,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RegistrationCompleted += x, x => _data.RegistrationCompleted -= x); + }, x => _data.RegistrationCompleted += x, x => _data.RegistrationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13041,9 +11683,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReRegistrationNeeded += x, x => _data.ReRegistrationNeeded -= x); + }, x => _data.ReRegistrationNeeded += x, x => _data.ReRegistrationNeeded -= x); } } @@ -13086,9 +11726,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13096,9 +11734,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResultGenerated += x, x => _data.ResultGenerated -= x); + }, x => _data.ResultGenerated += x, x => _data.ResultGenerated -= x); } /// @@ -13123,9 +11759,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HypothesisGenerated += x, x => _data.HypothesisGenerated -= x); + }, x => _data.HypothesisGenerated += x, x => _data.HypothesisGenerated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13133,9 +11767,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RecognitionQualityDegrading += x, x => _data.RecognitionQualityDegrading -= x); + }, x => _data.RecognitionQualityDegrading += x, x => _data.RecognitionQualityDegrading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13143,9 +11775,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -13188,9 +11818,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadBitrateChanged += x, x => _data.DownloadBitrateChanged -= x); + }, x => _data.DownloadBitrateChanged += x, x => _data.DownloadBitrateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13198,9 +11826,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13208,9 +11834,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13218,9 +11842,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadRequested += x, x => _data.DownloadRequested -= x); + }, x => _data.DownloadRequested += x, x => _data.DownloadRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13228,9 +11850,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackBitrateChanged += x, x => _data.PlaybackBitrateChanged -= x); + }, x => _data.PlaybackBitrateChanged += x, x => _data.PlaybackBitrateChanged -= x); } /// @@ -13255,9 +11875,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DiagnosticAvailable += x, x => _data.DiagnosticAvailable -= x); + }, x => _data.DiagnosticAvailable += x, x => _data.DiagnosticAvailable -= x); } } @@ -13296,9 +11914,7 @@ namespace Windows.Networking.BackgroundTransfer { void Handler(global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RangesDownloaded += x, x => _data.RangesDownloaded -= x); + }, x => _data.RangesDownloaded += x, x => _data.RangesDownloaded -= x); } } @@ -13361,9 +11977,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESim sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProfileChanged += x, x => _data.ProfileChanged -= x); + }, x => _data.ProfileChanged += x, x => _data.ProfileChanged -= x); } /// @@ -13388,9 +12002,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -13415,9 +12027,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13425,9 +12035,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13435,9 +12043,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13445,9 +12051,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13455,9 +12059,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -13482,9 +12084,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountAdded += x, x => _data.AccountAdded -= x); + }, x => _data.AccountAdded += x, x => _data.AccountAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13492,9 +12092,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountRemoved += x, x => _data.AccountRemoved -= x); + }, x => _data.AccountRemoved += x, x => _data.AccountRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13502,9 +12100,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountUpdated += x, x => _data.AccountUpdated -= x); + }, x => _data.AccountUpdated += x, x => _data.AccountUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13512,9 +12108,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13522,9 +12116,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -13549,9 +12141,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); } /// @@ -13576,9 +12166,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsInEmergencyCallModeChanged += x, x => _data.IsInEmergencyCallModeChanged -= x); + }, x => _data.IsInEmergencyCallModeChanged += x, x => _data.IsInEmergencyCallModeChanged -= x); } /// @@ -13603,9 +12191,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TransmissionStateChanged += x, x => _data.TransmissionStateChanged -= x); + }, x => _data.TransmissionStateChanged += x, x => _data.TransmissionStateChanged -= x); } } @@ -13648,9 +12234,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13658,9 +12242,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13668,9 +12250,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13678,9 +12258,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13688,9 +12266,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -13715,9 +12291,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); return Handler; - } - - , x => _data.DeviceArrived += x, x => _data.DeviceArrived -= x); + }, x => _data.DeviceArrived += x, x => _data.DeviceArrived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13725,9 +12299,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); return Handler; - } - - , x => _data.DeviceDeparted += x, x => _data.DeviceDeparted -= x); + }, x => _data.DeviceDeparted += x, x => _data.DeviceDeparted -= x); } } @@ -13766,9 +12338,7 @@ namespace Windows.Networking.PushNotifications { void Handler(global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PushNotificationReceived += x, x => _data.PushNotificationReceived -= x); + }, x => _data.PushNotificationReceived += x, x => _data.PushNotificationReceived -= x); } } @@ -13807,9 +12377,7 @@ namespace Windows.Networking.ServiceDiscovery.Dnssd { void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13817,9 +12385,7 @@ namespace Windows.Networking.ServiceDiscovery.Dnssd { void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13827,9 +12393,7 @@ namespace Windows.Networking.ServiceDiscovery.Dnssd { void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -13892,9 +12456,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } /// @@ -13919,9 +12481,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } /// @@ -13946,9 +12506,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13956,9 +12514,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13966,9 +12522,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); } /// @@ -13993,9 +12547,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14003,9 +12555,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } /// @@ -14030,9 +12580,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } /// @@ -14057,9 +12605,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionReceived += x, x => _data.ConnectionReceived -= x); + }, x => _data.ConnectionReceived += x, x => _data.ConnectionReceived -= x); } /// @@ -14084,9 +12630,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14094,9 +12638,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); } } @@ -14135,9 +12677,7 @@ namespace Windows.Networking.Vpn { void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActivityChange += x, x => _data.ActivityChange -= x); + }, x => _data.ActivityChange += x, x => _data.ActivityChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14145,9 +12685,7 @@ namespace Windows.Networking.Vpn { void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActivityStateChange += x, x => _data.ActivityStateChange -= x); + }, x => _data.ActivityStateChange += x, x => _data.ActivityStateChange -= x); } } @@ -14194,9 +12732,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RawCoordinateSystemAdjusted += x, x => _data.RawCoordinateSystemAdjusted -= x); + }, x => _data.RawCoordinateSystemAdjusted += x, x => _data.RawCoordinateSystemAdjusted -= x); } /// @@ -14221,9 +12757,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14231,9 +12765,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14241,9 +12773,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14251,9 +12781,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -14278,9 +12806,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LocatabilityChanged += x, x => _data.LocatabilityChanged -= x); + }, x => _data.LocatabilityChanged += x, x => _data.LocatabilityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14288,9 +12814,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionalTrackingDeactivating += x, x => _data.PositionalTrackingDeactivating -= x); + }, x => _data.PositionalTrackingDeactivating += x, x => _data.PositionalTrackingDeactivating -= x); } } @@ -14329,9 +12853,7 @@ namespace Windows.Perception.Spatial.Surfaces { void Handler(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ObservedSurfacesChanged += x, x => _data.ObservedSurfacesChanged -= x); + }, x => _data.ObservedSurfacesChanged += x, x => _data.ObservedSurfacesChanged -= x); } } @@ -14370,9 +12892,7 @@ namespace Windows.Phone.Devices.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingChargePercentChanged += x, x => _data.RemainingChargePercentChanged -= x); + }, x => _data.RemainingChargePercentChanged += x, x => _data.RemainingChargePercentChanged -= x); } } @@ -14411,9 +12931,7 @@ namespace Windows.Phone.Media.Devices { void Handler(global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioEndpointChanged += x, x => _data.AudioEndpointChanged -= x); + }, x => _data.AudioEndpointChanged += x, x => _data.AudioEndpointChanged -= x); } } @@ -14452,9 +12970,7 @@ namespace Windows.Security.Authentication.Web.Core { void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DefaultSignInAccountChanged += x, x => _data.DefaultSignInAccountChanged -= x); + }, x => _data.DefaultSignInAccountChanged += x, x => _data.DefaultSignInAccountChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14462,9 +12978,7 @@ namespace Windows.Security.Authentication.Web.Core { void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14472,9 +12986,7 @@ namespace Windows.Security.Authentication.Web.Core { void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -14513,9 +13025,7 @@ namespace Windows.Security.Credentials { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } } @@ -14554,9 +13064,7 @@ namespace Windows.Services.Maps.OfflineMaps { void Handler(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } } @@ -14607,9 +13115,7 @@ namespace Windows.Storage { void Handler(global::Windows.Storage.ApplicationData sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataChanged += x, x => _data.DataChanged -= x); + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); } /// @@ -14634,9 +13140,7 @@ namespace Windows.Storage { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -14661,9 +13165,7 @@ namespace Windows.Storage { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -14688,9 +13190,7 @@ namespace Windows.Storage { void Handler(global::Windows.Storage.StorageLibrary sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DefinitionChanged += x, x => _data.DefinitionChanged -= x); + }, x => _data.DefinitionChanged += x, x => _data.DefinitionChanged -= x); } } @@ -14729,9 +13229,7 @@ namespace Windows.Storage.AccessCache { void Handler(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); } } @@ -14778,9 +13276,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14788,9 +13284,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); } /// @@ -14815,9 +13309,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14825,9 +13317,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); } /// @@ -14852,9 +13342,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14862,9 +13350,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); } } @@ -14907,9 +13393,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14917,9 +13401,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileRemoved += x, x => _data.FileRemoved -= x); + }, x => _data.FileRemoved += x, x => _data.FileRemoved -= x); } /// @@ -14944,9 +13426,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileNameChanged += x, x => _data.FileNameChanged -= x); + }, x => _data.FileNameChanged += x, x => _data.FileNameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14954,9 +13434,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetFileRequested += x, x => _data.TargetFileRequested -= x); + }, x => _data.TargetFileRequested += x, x => _data.TargetFileRequested -= x); } } @@ -14995,9 +13473,7 @@ namespace Windows.Storage.Provider { void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileUpdateRequested += x, x => _data.FileUpdateRequested -= x); + }, x => _data.FileUpdateRequested += x, x => _data.FileUpdateRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15005,9 +13481,7 @@ namespace Windows.Storage.Provider { void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UIRequested += x, x => _data.UIRequested -= x); + }, x => _data.UIRequested += x, x => _data.UIRequested -= x); } } @@ -15058,9 +13532,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15068,9 +13540,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } /// @@ -15095,9 +13565,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15105,9 +13573,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } /// @@ -15132,9 +13598,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15142,9 +13606,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } /// @@ -15169,9 +13631,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15179,9 +13639,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } } @@ -15236,9 +13694,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15246,9 +13702,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15256,9 +13710,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15266,9 +13718,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -15293,9 +13743,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15303,9 +13751,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15313,9 +13759,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ExecutionStateChanged += x, x => _data.ExecutionStateChanged -= x); + }, x => _data.ExecutionStateChanged += x, x => _data.ExecutionStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15323,9 +13767,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15333,9 +13775,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -15360,9 +13800,7 @@ namespace Windows.System { void Handler(global::Windows.System.DispatcherQueue sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShutdownCompleted += x, x => _data.ShutdownCompleted -= x); + }, x => _data.ShutdownCompleted += x, x => _data.ShutdownCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15370,9 +13808,7 @@ namespace Windows.System { void Handler(global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShutdownStarting += x, x => _data.ShutdownStarting -= x); + }, x => _data.ShutdownStarting += x, x => _data.ShutdownStarting -= x); } /// @@ -15397,9 +13833,7 @@ namespace Windows.System { void Handler(global::Windows.System.DispatcherQueueTimer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// @@ -15424,9 +13858,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15434,9 +13866,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AuthenticationStatusChanged += x, x => _data.AuthenticationStatusChanged -= x); + }, x => _data.AuthenticationStatusChanged += x, x => _data.AuthenticationStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15444,9 +13874,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AuthenticationStatusChanging += x, x => _data.AuthenticationStatusChanging -= x); + }, x => _data.AuthenticationStatusChanging += x, x => _data.AuthenticationStatusChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15454,9 +13882,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15464,9 +13890,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15474,9 +13898,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15484,9 +13906,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -15525,9 +13945,7 @@ namespace Windows.System.Diagnostics.DevicePortal { void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15535,9 +13953,7 @@ namespace Windows.System.Diagnostics.DevicePortal { void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); } } @@ -15576,9 +13992,7 @@ namespace Windows.System.Preview { void Handler(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PostureChanged += x, x => _data.PostureChanged -= x); + }, x => _data.PostureChanged += x, x => _data.PostureChanged -= x); } } @@ -15641,9 +14055,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Disconnected += x, x => _data.Disconnected -= x); + }, x => _data.Disconnected += x, x => _data.Disconnected -= x); } /// @@ -15668,9 +14080,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.JoinRequested += x, x => _data.JoinRequested -= x); + }, x => _data.JoinRequested += x, x => _data.JoinRequested -= x); } /// @@ -15695,9 +14105,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InvitationReceived += x, x => _data.InvitationReceived -= x); + }, x => _data.InvitationReceived += x, x => _data.InvitationReceived -= x); } /// @@ -15722,9 +14130,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValueSetReceived += x, x => _data.ValueSetReceived -= x); + }, x => _data.ValueSetReceived += x, x => _data.ValueSetReceived -= x); } /// @@ -15749,9 +14155,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15759,9 +14163,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15769,9 +14171,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); } /// @@ -15796,9 +14196,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15806,9 +14204,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15816,9 +14212,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -15843,9 +14237,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15853,9 +14245,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15863,9 +14253,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteSystemAdded += x, x => _data.RemoteSystemAdded -= x); + }, x => _data.RemoteSystemAdded += x, x => _data.RemoteSystemAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15873,9 +14261,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteSystemRemoved += x, x => _data.RemoteSystemRemoved -= x); + }, x => _data.RemoteSystemRemoved += x, x => _data.RemoteSystemRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15883,9 +14269,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteSystemUpdated += x, x => _data.RemoteSystemUpdated -= x); + }, x => _data.RemoteSystemUpdated += x, x => _data.RemoteSystemUpdated -= x); } } @@ -15924,9 +14308,7 @@ namespace Windows.UI.Accessibility { void Handler(global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenReaderPositionChanged += x, x => _data.ScreenReaderPositionChanged -= x); + }, x => _data.ScreenReaderPositionChanged += x, x => _data.ScreenReaderPositionChanged -= x); } } @@ -15965,9 +14347,7 @@ namespace Windows.UI.ApplicationSettings { void Handler(global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountCommandsRequested += x, x => _data.AccountCommandsRequested -= x); + }, x => _data.AccountCommandsRequested += x, x => _data.AccountCommandsRequested -= x); } } @@ -16018,9 +14398,7 @@ namespace Windows.UI.Composition { void Handler(global::Windows.UI.Composition.CompositionCapabilities sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } /// @@ -16045,9 +14423,7 @@ namespace Windows.UI.Composition { void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -16072,9 +14448,7 @@ namespace Windows.UI.Composition { void Handler(global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RenderingDeviceReplaced += x, x => _data.RenderingDeviceReplaced -= x); + }, x => _data.RenderingDeviceReplaced += x, x => _data.RenderingDeviceReplaced -= x); } /// @@ -16099,9 +14473,7 @@ namespace Windows.UI.Composition { void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } } @@ -16140,9 +14512,7 @@ namespace Windows.UI.Composition.Core { void Handler(global::Windows.UI.Composition.Core.CompositorController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CommitNeeded += x, x => _data.CommitNeeded -= x); + }, x => _data.CommitNeeded += x, x => _data.CommitNeeded -= x); } } @@ -16221,9 +14591,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); } /// @@ -16248,9 +14616,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16258,9 +14624,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16268,9 +14632,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16278,9 +14640,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16288,9 +14648,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16298,9 +14656,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16308,9 +14664,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16318,9 +14672,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16328,9 +14680,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16338,9 +14688,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16348,9 +14696,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16358,9 +14704,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16368,9 +14712,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16378,9 +14720,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16388,9 +14728,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); } /// @@ -16415,9 +14753,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); } /// @@ -16442,9 +14778,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16452,9 +14786,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16462,9 +14794,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16472,9 +14802,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16482,9 +14810,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16492,9 +14818,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16502,9 +14826,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16512,9 +14834,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); } /// @@ -16539,9 +14859,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16549,9 +14867,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16559,9 +14875,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16569,9 +14883,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16579,9 +14891,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16589,9 +14899,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16599,9 +14907,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16609,9 +14915,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16619,9 +14923,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16629,9 +14931,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16639,9 +14939,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16649,9 +14947,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16659,9 +14955,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16669,9 +14963,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16679,9 +14971,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16689,9 +14979,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16699,9 +14987,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16709,9 +14995,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16719,9 +15003,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResizeCompleted += x, x => _data.ResizeCompleted -= x); + }, x => _data.ResizeCompleted += x, x => _data.ResizeCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16729,9 +15011,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResizeStarted += x, x => _data.ResizeStarted -= x); + }, x => _data.ResizeStarted += x, x => _data.ResizeStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16739,9 +15019,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16749,9 +15027,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16759,9 +15035,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } /// @@ -16786,9 +15060,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); } /// @@ -16813,9 +15085,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); } /// @@ -16840,9 +15110,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16850,9 +15118,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16860,9 +15126,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16870,9 +15134,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16880,9 +15142,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16890,9 +15150,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16900,9 +15158,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); } /// @@ -16927,9 +15183,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16937,9 +15191,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16947,9 +15199,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); } /// @@ -16974,9 +15224,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16984,9 +15232,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16994,9 +15240,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17004,9 +15248,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17014,9 +15256,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17024,9 +15264,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17034,9 +15272,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17044,9 +15280,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17054,9 +15288,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17064,9 +15296,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17074,9 +15304,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17084,9 +15312,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17094,9 +15320,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17104,9 +15328,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17114,9 +15336,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17124,9 +15344,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17134,9 +15352,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } /// @@ -17161,9 +15377,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.BackRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackRequested += x, x => _data.BackRequested -= x); + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); } } @@ -17202,9 +15416,7 @@ namespace Windows.UI.Core.Preview { void Handler(object sender, global::Windows.UI.Core.Preview.SystemNavigationCloseRequestedPreviewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); } } @@ -17259,9 +15471,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17269,9 +15479,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17279,9 +15487,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Starting += x, x => _data.Starting -= x); + }, x => _data.Starting += x, x => _data.Starting -= x); } /// @@ -17306,9 +15512,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CrossSliding += x, x => _data.CrossSliding -= x); + }, x => _data.CrossSliding += x, x => _data.CrossSliding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17316,9 +15520,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Dragging += x, x => _data.Dragging -= x); + }, x => _data.Dragging += x, x => _data.Dragging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17326,9 +15528,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Holding += x, x => _data.Holding -= x); + }, x => _data.Holding += x, x => _data.Holding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17336,9 +15536,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17346,9 +15544,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17356,9 +15552,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17366,9 +15560,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17376,9 +15568,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RightTapped += x, x => _data.RightTapped -= x); + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17386,9 +15576,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -17413,9 +15601,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17423,9 +15609,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); } /// @@ -17450,9 +15634,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonClicked += x, x => _data.ButtonClicked -= x); + }, x => _data.ButtonClicked += x, x => _data.ButtonClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17460,9 +15642,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonHolding += x, x => _data.ButtonHolding -= x); + }, x => _data.ButtonHolding += x, x => _data.ButtonHolding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17470,9 +15650,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17480,9 +15658,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonReleased += x, x => _data.ButtonReleased -= x); + }, x => _data.ButtonReleased += x, x => _data.ButtonReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17490,9 +15666,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ControlAcquired += x, x => _data.ControlAcquired -= x); + }, x => _data.ControlAcquired += x, x => _data.ControlAcquired -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17500,9 +15674,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ControlLost += x, x => _data.ControlLost -= x); + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17510,9 +15682,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RotationChanged += x, x => _data.RotationChanged -= x); + }, x => _data.RotationChanged += x, x => _data.RotationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17520,9 +15690,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenContactContinued += x, x => _data.ScreenContactContinued -= x); + }, x => _data.ScreenContactContinued += x, x => _data.ScreenContactContinued -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17530,9 +15698,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenContactEnded += x, x => _data.ScreenContactEnded -= x); + }, x => _data.ScreenContactEnded += x, x => _data.ScreenContactEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17540,9 +15706,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenContactStarted += x, x => _data.ScreenContactStarted -= x); + }, x => _data.ScreenContactStarted += x, x => _data.ScreenContactStarted -= x); } /// @@ -17567,9 +15731,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialControllerMenuItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } } @@ -17616,9 +15778,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokesCollected += x, x => _data.StrokesCollected -= x); + }, x => _data.StrokesCollected += x, x => _data.StrokesCollected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17626,9 +15786,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokesErased += x, x => _data.StrokesErased -= x); + }, x => _data.StrokesErased += x, x => _data.StrokesErased -= x); } /// @@ -17653,9 +15811,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeCanceled += x, x => _data.StrokeCanceled -= x); + }, x => _data.StrokeCanceled += x, x => _data.StrokeCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17663,9 +15819,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeContinued += x, x => _data.StrokeContinued -= x); + }, x => _data.StrokeContinued += x, x => _data.StrokeContinued -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17673,9 +15827,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeEnded += x, x => _data.StrokeEnded -= x); + }, x => _data.StrokeEnded += x, x => _data.StrokeEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17683,9 +15835,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeStarted += x, x => _data.StrokeStarted -= x); + }, x => _data.StrokeStarted += x, x => _data.StrokeStarted -= x); } /// @@ -17710,9 +15860,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17720,9 +15868,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17730,9 +15876,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerHovered += x, x => _data.PointerHovered -= x); + }, x => _data.PointerHovered += x, x => _data.PointerHovered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17740,9 +15884,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerLost += x, x => _data.PointerLost -= x); + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17750,9 +15892,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17760,9 +15900,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17770,9 +15908,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); } } @@ -17815,9 +15951,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntering += x, x => _data.PointerEntering -= x); + }, x => _data.PointerEntering += x, x => _data.PointerEntering -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17825,9 +15959,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExiting += x, x => _data.PointerExiting -= x); + }, x => _data.PointerExiting += x, x => _data.PointerExiting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17835,9 +15967,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerHovering += x, x => _data.PointerHovering -= x); + }, x => _data.PointerHovering += x, x => _data.PointerHovering -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17845,9 +15975,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerLost += x, x => _data.PointerLost -= x); + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17855,9 +15983,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoving += x, x => _data.PointerMoving -= x); + }, x => _data.PointerMoving += x, x => _data.PointerMoving -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17865,9 +15991,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressing += x, x => _data.PointerPressing -= x); + }, x => _data.PointerPressing += x, x => _data.PointerPressing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17875,9 +15999,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleasing += x, x => _data.PointerReleasing -= x); + }, x => _data.PointerReleasing += x, x => _data.PointerReleasing -= x); } /// @@ -17902,9 +16024,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeCanceled += x, x => _data.WetStrokeCanceled -= x); + }, x => _data.WetStrokeCanceled += x, x => _data.WetStrokeCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17912,9 +16032,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeCompleted += x, x => _data.WetStrokeCompleted -= x); + }, x => _data.WetStrokeCompleted += x, x => _data.WetStrokeCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17922,9 +16040,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeContinuing += x, x => _data.WetStrokeContinuing -= x); + }, x => _data.WetStrokeContinuing += x, x => _data.WetStrokeContinuing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17932,9 +16048,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeStarting += x, x => _data.WetStrokeStarting -= x); + }, x => _data.WetStrokeStarting += x, x => _data.WetStrokeStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17942,9 +16056,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeStopping += x, x => _data.WetStrokeStopping -= x); + }, x => _data.WetStrokeStopping += x, x => _data.WetStrokeStopping -= x); } } @@ -17987,9 +16099,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HoldCanceled += x, x => _data.HoldCanceled -= x); + }, x => _data.HoldCanceled += x, x => _data.HoldCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17997,9 +16107,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HoldCompleted += x, x => _data.HoldCompleted -= x); + }, x => _data.HoldCompleted += x, x => _data.HoldCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18007,9 +16115,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HoldStarted += x, x => _data.HoldStarted -= x); + }, x => _data.HoldStarted += x, x => _data.HoldStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18017,9 +16123,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationCanceled += x, x => _data.ManipulationCanceled -= x); + }, x => _data.ManipulationCanceled += x, x => _data.ManipulationCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18027,9 +16131,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18037,9 +16139,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18047,9 +16147,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18057,9 +16155,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCanceled += x, x => _data.NavigationCanceled -= x); + }, x => _data.NavigationCanceled += x, x => _data.NavigationCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18067,9 +16163,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18077,9 +16171,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarted += x, x => _data.NavigationStarted -= x); + }, x => _data.NavigationStarted += x, x => _data.NavigationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18087,9 +16179,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationUpdated += x, x => _data.NavigationUpdated -= x); + }, x => _data.NavigationUpdated += x, x => _data.NavigationUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18097,9 +16187,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RecognitionEnded += x, x => _data.RecognitionEnded -= x); + }, x => _data.RecognitionEnded += x, x => _data.RecognitionEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18107,9 +16195,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RecognitionStarted += x, x => _data.RecognitionStarted -= x); + }, x => _data.RecognitionStarted += x, x => _data.RecognitionStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18117,9 +16203,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -18144,9 +16228,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InteractionDetected += x, x => _data.InteractionDetected -= x); + }, x => _data.InteractionDetected += x, x => _data.InteractionDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18154,9 +16236,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceDetected += x, x => _data.SourceDetected -= x); + }, x => _data.SourceDetected += x, x => _data.SourceDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18164,9 +16244,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceLost += x, x => _data.SourceLost -= x); + }, x => _data.SourceLost += x, x => _data.SourceLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18174,9 +16252,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourcePressed += x, x => _data.SourcePressed -= x); + }, x => _data.SourcePressed += x, x => _data.SourcePressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18184,9 +16260,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceReleased += x, x => _data.SourceReleased -= x); + }, x => _data.SourceReleased += x, x => _data.SourceReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18194,9 +16268,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); } } @@ -18239,9 +16311,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotification sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18249,9 +16319,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18259,9 +16327,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Failed += x, x => _data.Failed -= x); + }, x => _data.Failed += x, x => _data.Failed -= x); } /// @@ -18286,9 +16352,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScheduledToastNotificationShowing += x, x => _data.ScheduledToastNotificationShowing -= x); + }, x => _data.ScheduledToastNotificationShowing += x, x => _data.ScheduledToastNotificationShowing -= x); } } @@ -18327,9 +16391,7 @@ namespace Windows.UI.Notifications.Management { void Handler(global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NotificationChanged += x, x => _data.NotificationChanged -= x); + }, x => _data.NotificationChanged += x, x => _data.NotificationChanged -= x); } } @@ -18368,9 +16430,7 @@ namespace Windows.UI.StartScreen { void Handler(global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisualElementsRequested += x, x => _data.VisualElementsRequested -= x); + }, x => _data.VisualElementsRequested += x, x => _data.VisualElementsRequested -= x); } } @@ -18413,9 +16473,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompositionCompleted += x, x => _data.CompositionCompleted -= x); + }, x => _data.CompositionCompleted += x, x => _data.CompositionCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18423,9 +16481,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompositionStarted += x, x => _data.CompositionStarted -= x); + }, x => _data.CompositionStarted += x, x => _data.CompositionStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18433,9 +16489,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusRemoved += x, x => _data.FocusRemoved -= x); + }, x => _data.FocusRemoved += x, x => _data.FocusRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18443,9 +16497,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FormatUpdating += x, x => _data.FormatUpdating -= x); + }, x => _data.FormatUpdating += x, x => _data.FormatUpdating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18453,9 +16505,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LayoutRequested += x, x => _data.LayoutRequested -= x); + }, x => _data.LayoutRequested += x, x => _data.LayoutRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18463,9 +16513,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NotifyFocusLeaveCompleted += x, x => _data.NotifyFocusLeaveCompleted -= x); + }, x => _data.NotifyFocusLeaveCompleted += x, x => _data.NotifyFocusLeaveCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18473,9 +16521,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionRequested += x, x => _data.SelectionRequested -= x); + }, x => _data.SelectionRequested += x, x => _data.SelectionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18483,9 +16529,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionUpdating += x, x => _data.SelectionUpdating -= x); + }, x => _data.SelectionUpdating += x, x => _data.SelectionUpdating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18493,9 +16537,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextRequested += x, x => _data.TextRequested -= x); + }, x => _data.TextRequested += x, x => _data.TextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18503,9 +16545,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextUpdating += x, x => _data.TextUpdating -= x); + }, x => _data.TextUpdating += x, x => _data.TextUpdating -= x); } /// @@ -18530,9 +16570,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); } } @@ -18587,9 +16625,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HighContrastChanged += x, x => _data.HighContrastChanged -= x); + }, x => _data.HighContrastChanged += x, x => _data.HighContrastChanged -= x); } /// @@ -18614,9 +16650,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Consolidated += x, x => _data.Consolidated -= x); + }, x => _data.Consolidated += x, x => _data.Consolidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18624,9 +16658,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisibleBoundsChanged += x, x => _data.VisibleBoundsChanged -= x); + }, x => _data.VisibleBoundsChanged += x, x => _data.VisibleBoundsChanged -= x); } /// @@ -18651,9 +16683,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Hiding += x, x => _data.Hiding -= x); + }, x => _data.Hiding += x, x => _data.Hiding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18661,9 +16691,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Showing += x, x => _data.Showing -= x); + }, x => _data.Showing += x, x => _data.Showing -= x); } /// @@ -18688,9 +16716,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Hiding += x, x => _data.Hiding -= x); + }, x => _data.Hiding += x, x => _data.Hiding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18698,9 +16724,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Showing += x, x => _data.Showing -= x); + }, x => _data.Showing += x, x => _data.Showing -= x); } /// @@ -18725,9 +16749,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvancedEffectsEnabledChanged += x, x => _data.AdvancedEffectsEnabledChanged -= x); + }, x => _data.AdvancedEffectsEnabledChanged += x, x => _data.AdvancedEffectsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18735,9 +16757,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorValuesChanged += x, x => _data.ColorValuesChanged -= x); + }, x => _data.ColorValuesChanged += x, x => _data.ColorValuesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18745,9 +16765,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextScaleFactorChanged += x, x => _data.TextScaleFactorChanged -= x); + }, x => _data.TextScaleFactorChanged += x, x => _data.TextScaleFactorChanged -= x); } } @@ -18786,9 +16804,7 @@ namespace Windows.UI.ViewManagement.Core { void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OcclusionsChanged += x, x => _data.OcclusionsChanged -= x); + }, x => _data.OcclusionsChanged += x, x => _data.OcclusionsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18796,9 +16812,7 @@ namespace Windows.UI.ViewManagement.Core { void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.XYFocusTransferredToPrimaryView += x, x => _data.XYFocusTransferredToPrimaryView -= x); + }, x => _data.XYFocusTransferredToPrimaryView += x, x => _data.XYFocusTransferredToPrimaryView -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18806,9 +16820,7 @@ namespace Windows.UI.ViewManagement.Core { void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.XYFocusTransferringFromPrimaryView += x, x => _data.XYFocusTransferringFromPrimaryView -= x); + }, x => _data.XYFocusTransferringFromPrimaryView += x, x => _data.XYFocusTransferringFromPrimaryView -= x); } } @@ -18851,9 +16863,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); } /// @@ -18878,9 +16888,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18888,9 +16896,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.UI.WebUI.WebUIView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18898,9 +16904,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18908,9 +16912,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18918,9 +16920,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18928,9 +16928,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18938,9 +16936,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18948,9 +16944,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18958,9 +16952,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18968,9 +16960,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18978,9 +16968,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18988,9 +16976,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18998,9 +16984,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19008,9 +16992,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19018,9 +17000,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19028,9 +17008,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19038,9 +17016,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19048,9 +17024,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19058,9 +17032,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } } @@ -19179,9 +17151,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EnteredBackground += x, x => _data.EnteredBackground -= x); + }, x => _data.EnteredBackground += x, x => _data.EnteredBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19189,9 +17159,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LeavingBackground += x, x => _data.LeavingBackground -= x); + }, x => _data.LeavingBackground += x, x => _data.LeavingBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19199,9 +17167,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Resuming += x, x => _data.Resuming -= x); + }, x => _data.Resuming += x, x => _data.Resuming -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19209,9 +17175,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Suspending += x, x => _data.Suspending -= x); + }, x => _data.Suspending += x, x => _data.Suspending -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19219,9 +17183,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.UnhandledExceptionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); } /// @@ -19246,9 +17208,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19273,9 +17233,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.BindingFailedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingFailed += x, x => _data.BindingFailed -= x); + }, x => _data.BindingFailed += x, x => _data.BindingFailed -= x); } /// @@ -19300,9 +17258,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19327,9 +17283,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// @@ -19354,9 +17308,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.FrameworkElement sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActualThemeChanged += x, x => _data.ActualThemeChanged -= x); + }, x => _data.ActualThemeChanged += x, x => _data.ActualThemeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19364,9 +17316,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EffectiveViewportChanged += x, x => _data.EffectiveViewportChanged -= x); + }, x => _data.EffectiveViewportChanged += x, x => _data.EffectiveViewportChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19374,9 +17324,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19384,9 +17332,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19394,9 +17340,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19404,9 +17348,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19414,9 +17356,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19424,9 +17364,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19434,9 +17372,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19444,9 +17380,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -19471,9 +17405,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19498,9 +17430,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19508,9 +17438,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19518,9 +17446,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19528,9 +17454,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -19555,9 +17479,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19582,9 +17504,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19609,9 +17529,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19636,9 +17554,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19663,9 +17579,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19690,9 +17604,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19717,9 +17629,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19744,9 +17654,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19754,9 +17662,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19764,9 +17670,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19774,9 +17678,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BringIntoViewRequested += x, x => _data.BringIntoViewRequested -= x); + }, x => _data.BringIntoViewRequested += x, x => _data.BringIntoViewRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19784,9 +17686,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19794,9 +17694,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContextCanceled += x, x => _data.ContextCanceled -= x); + }, x => _data.ContextCanceled += x, x => _data.ContextCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19804,9 +17702,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContextRequested += x, x => _data.ContextRequested -= x); + }, x => _data.ContextRequested += x, x => _data.ContextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19814,9 +17710,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); + }, x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19824,9 +17718,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragEnter += x, x => _data.DragEnter -= x); + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19834,9 +17726,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragLeave += x, x => _data.DragLeave -= x); + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19844,9 +17734,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragOver += x, x => _data.DragOver -= x); + }, x => _data.DragOver += x, x => _data.DragOver -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19854,9 +17742,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragStarting += x, x => _data.DragStarting -= x); + }, x => _data.DragStarting += x, x => _data.DragStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19864,9 +17750,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drop += x, x => _data.Drop -= x); + }, x => _data.Drop += x, x => _data.Drop -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19874,9 +17758,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DropCompleted += x, x => _data.DropCompleted -= x); + }, x => _data.DropCompleted += x, x => _data.DropCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19884,9 +17766,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GettingFocus += x, x => _data.GettingFocus -= x); + }, x => _data.GettingFocus += x, x => _data.GettingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19894,9 +17774,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19904,9 +17782,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.HoldingRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Holding += x, x => _data.Holding -= x); + }, x => _data.Holding += x, x => _data.Holding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19914,9 +17790,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19924,9 +17798,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19934,9 +17806,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19944,9 +17814,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19954,9 +17822,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19964,9 +17830,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19974,9 +17838,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19984,9 +17846,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19994,9 +17854,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20004,9 +17862,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NoFocusCandidateFound += x, x => _data.NoFocusCandidateFound -= x); + }, x => _data.NoFocusCandidateFound += x, x => _data.NoFocusCandidateFound -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20014,9 +17870,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerCanceled += x, x => _data.PointerCanceled -= x); + }, x => _data.PointerCanceled += x, x => _data.PointerCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20024,9 +17878,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20034,9 +17886,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20044,9 +17894,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20054,9 +17902,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20064,9 +17910,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20074,9 +17918,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20084,9 +17926,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20094,9 +17934,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20104,9 +17942,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20114,9 +17950,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProcessKeyboardAccelerators += x, x => _data.ProcessKeyboardAccelerators -= x); + }, x => _data.ProcessKeyboardAccelerators += x, x => _data.ProcessKeyboardAccelerators -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20124,9 +17958,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.RightTappedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RightTapped += x, x => _data.RightTapped -= x); + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20134,9 +17966,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.TappedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -20161,9 +17991,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20188,9 +18016,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20198,9 +18024,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20208,9 +18032,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20235,9 +18057,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20262,9 +18082,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20289,9 +18107,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.WindowActivatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20299,9 +18115,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20309,9 +18123,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.WindowSizeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20319,9 +18131,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.VisibilityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } } @@ -20360,9 +18170,7 @@ namespace Windows.UI.Xaml.Automation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -20405,9 +18213,7 @@ namespace Windows.UI.Xaml.Automation.Peers { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20432,9 +18238,7 @@ namespace Windows.UI.Xaml.Automation.Peers { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -20473,9 +18277,7 @@ namespace Windows.UI.Xaml.Automation.Provider { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -20838,9 +18640,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20848,9 +18648,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20858,9 +18656,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20868,9 +18664,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opening += x, x => _data.Opening -= x); + }, x => _data.Opening += x, x => _data.Opening -= x); } /// @@ -20895,9 +18689,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20905,9 +18697,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SuggestionChosen += x, x => _data.SuggestionChosen -= x); + }, x => _data.SuggestionChosen += x, x => _data.SuggestionChosen -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20915,9 +18705,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -20942,9 +18730,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20969,9 +18755,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20996,9 +18780,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21023,9 +18805,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs e) => eventHandler((sender, e)); return Handler; - } - - , x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21033,9 +18813,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21043,9 +18821,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DateChanged += x, x => _data.DateChanged -= x); + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21053,9 +18829,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -21080,9 +18854,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21090,9 +18862,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); } /// @@ -21117,9 +18887,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); } /// @@ -21144,9 +18912,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21171,9 +18937,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21181,9 +18945,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21191,9 +18953,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextSubmitted += x, x => _data.TextSubmitted -= x); + }, x => _data.TextSubmitted += x, x => _data.TextSubmitted -= x); } /// @@ -21218,9 +18978,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DynamicOverflowItemsChanging += x, x => _data.DynamicOverflowItemsChanging -= x); + }, x => _data.DynamicOverflowItemsChanging += x, x => _data.DynamicOverflowItemsChanging -= x); } /// @@ -21245,9 +19003,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CloseButtonClick += x, x => _data.CloseButtonClick -= x); + }, x => _data.CloseButtonClick += x, x => _data.CloseButtonClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21255,9 +19011,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21265,9 +19019,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21275,9 +19027,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21285,9 +19035,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrimaryButtonClick += x, x => _data.PrimaryButtonClick -= x); + }, x => _data.PrimaryButtonClick += x, x => _data.PrimaryButtonClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21295,9 +19043,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SecondaryButtonClick += x, x => _data.SecondaryButtonClick -= x); + }, x => _data.SecondaryButtonClick += x, x => _data.SecondaryButtonClick -= x); } /// @@ -21322,9 +19068,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusDisengaged += x, x => _data.FocusDisengaged -= x); + }, x => _data.FocusDisengaged += x, x => _data.FocusDisengaged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21332,9 +19076,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusEngaged += x, x => _data.FocusEngaged -= x); + }, x => _data.FocusEngaged += x, x => _data.FocusEngaged -= x); } /// @@ -21359,9 +19101,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21386,9 +19126,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateChanged += x, x => _data.DateChanged -= x); + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21396,9 +19134,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); } /// @@ -21423,9 +19159,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DatePicked += x, x => _data.DatePicked -= x); + }, x => _data.DatePicked += x, x => _data.DatePicked -= x); } /// @@ -21450,9 +19184,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21477,9 +19209,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21487,9 +19217,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21497,9 +19225,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationFailedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21507,9 +19233,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); } /// @@ -21534,9 +19258,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -21561,9 +19283,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21571,9 +19291,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -21598,9 +19316,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.HubSectionHeaderClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SectionHeaderClick += x, x => _data.SectionHeaderClick -= x); + }, x => _data.SectionHeaderClick += x, x => _data.SectionHeaderClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21608,9 +19324,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SectionsInViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SectionsInViewChanged += x, x => _data.SectionsInViewChanged -= x); + }, x => _data.SectionsInViewChanged += x, x => _data.SectionsInViewChanged -= x); } /// @@ -21635,9 +19349,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21662,9 +19374,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21672,9 +19382,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21682,9 +19390,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21692,9 +19398,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21702,9 +19406,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21712,9 +19414,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21722,9 +19422,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21732,9 +19430,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21742,9 +19438,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21752,9 +19446,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21762,9 +19454,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -21789,9 +19479,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveToolChanged += x, x => _data.ActiveToolChanged -= x); + }, x => _data.ActiveToolChanged += x, x => _data.ActiveToolChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21799,9 +19487,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EraseAllClicked += x, x => _data.EraseAllClicked -= x); + }, x => _data.EraseAllClicked += x, x => _data.EraseAllClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21809,9 +19495,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InkDrawingAttributesChanged += x, x => _data.InkDrawingAttributesChanged -= x); + }, x => _data.InkDrawingAttributesChanged += x, x => _data.InkDrawingAttributesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21819,9 +19503,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsRulerButtonCheckedChanged += x, x => _data.IsRulerButtonCheckedChanged -= x); + }, x => _data.IsRulerButtonCheckedChanged += x, x => _data.IsRulerButtonCheckedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21829,9 +19511,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsStencilButtonCheckedChanged += x, x => _data.IsStencilButtonCheckedChanged -= x); + }, x => _data.IsStencilButtonCheckedChanged += x, x => _data.IsStencilButtonCheckedChanged -= x); } /// @@ -21856,9 +19536,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21883,9 +19561,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Checked += x, x => _data.Checked -= x); + }, x => _data.Checked += x, x => _data.Checked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21893,9 +19569,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Unchecked += x, x => _data.Unchecked -= x); + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); } /// @@ -21920,9 +19594,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21930,9 +19602,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -21957,9 +19627,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -21984,9 +19652,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); } /// @@ -22011,9 +19677,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); } /// @@ -22038,9 +19702,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22065,9 +19727,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22075,9 +19735,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -22102,9 +19760,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemsPicked += x, x => _data.ItemsPicked -= x); + }, x => _data.ItemsPicked += x, x => _data.ItemsPicked -= x); } /// @@ -22129,9 +19785,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ChoosingGroupHeaderContainer += x, x => _data.ChoosingGroupHeaderContainer -= x); + }, x => _data.ChoosingGroupHeaderContainer += x, x => _data.ChoosingGroupHeaderContainer -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22139,9 +19793,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ChoosingItemContainer += x, x => _data.ChoosingItemContainer -= x); + }, x => _data.ChoosingItemContainer += x, x => _data.ChoosingItemContainer -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22149,9 +19801,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainerContentChanging += x, x => _data.ContainerContentChanging -= x); + }, x => _data.ContainerContentChanging += x, x => _data.ContainerContentChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22159,9 +19809,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22169,9 +19817,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.DragItemsStartingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22179,9 +19825,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ItemClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemClick += x, x => _data.ItemClick -= x); + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); } /// @@ -22206,9 +19850,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22216,9 +19858,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22226,9 +19866,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22236,9 +19874,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Media.TimelineMarkerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MarkerReached += x, x => _data.MarkerReached -= x); + }, x => _data.MarkerReached += x, x => _data.MarkerReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22246,9 +19882,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22256,9 +19890,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22266,9 +19898,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22276,9 +19906,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PartialMediaFailureDetected += x, x => _data.PartialMediaFailureDetected -= x); + }, x => _data.PartialMediaFailureDetected += x, x => _data.PartialMediaFailureDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22286,9 +19914,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Media.RateChangedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RateChanged += x, x => _data.RateChanged -= x); + }, x => _data.RateChanged += x, x => _data.RateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22296,9 +19922,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22306,9 +19930,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); } /// @@ -22333,9 +19955,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailRequested += x, x => _data.ThumbnailRequested -= x); + }, x => _data.ThumbnailRequested += x, x => _data.ThumbnailRequested -= x); } /// @@ -22360,9 +19980,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -22387,9 +20005,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22397,9 +20013,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22407,9 +20021,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22417,9 +20029,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22427,9 +20037,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22437,9 +20045,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22447,9 +20053,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22457,9 +20061,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22467,9 +20069,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22477,9 +20077,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22487,9 +20085,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -22514,9 +20110,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22524,9 +20118,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22534,9 +20126,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22544,9 +20134,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22554,9 +20142,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22564,9 +20150,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22574,9 +20158,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22584,9 +20166,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22594,9 +20174,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -22621,9 +20199,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BackRequested += x, x => _data.BackRequested -= x); + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22631,9 +20207,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22641,9 +20215,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22651,9 +20223,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22661,9 +20231,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22671,9 +20239,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22681,9 +20247,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22691,9 +20255,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -22718,9 +20280,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22745,9 +20305,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22755,9 +20313,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22765,9 +20321,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PasswordChanging += x, x => _data.PasswordChanging -= x); + }, x => _data.PasswordChanging += x, x => _data.PasswordChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22775,9 +20329,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paste += x, x => _data.Paste -= x); + }, x => _data.Paste += x, x => _data.Paste -= x); } /// @@ -22802,9 +20354,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22829,9 +20379,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Confirmed += x, x => _data.Confirmed -= x); + }, x => _data.Confirmed += x, x => _data.Confirmed -= x); } /// @@ -22856,9 +20404,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemLoaded += x, x => _data.PivotItemLoaded -= x); + }, x => _data.PivotItemLoaded += x, x => _data.PivotItemLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22866,9 +20412,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemLoading += x, x => _data.PivotItemLoading -= x); + }, x => _data.PivotItemLoading += x, x => _data.PivotItemLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22876,9 +20420,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemUnloaded += x, x => _data.PivotItemUnloaded -= x); + }, x => _data.PivotItemUnloaded += x, x => _data.PivotItemUnloaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22886,9 +20428,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemUnloading += x, x => _data.PivotItemUnloading -= x); + }, x => _data.PivotItemUnloading += x, x => _data.PivotItemUnloading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22896,9 +20436,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -22923,9 +20461,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22933,9 +20469,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -22960,9 +20494,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22970,9 +20502,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22980,9 +20510,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22990,9 +20518,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23000,9 +20526,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23010,9 +20534,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23020,9 +20542,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23030,9 +20550,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -23057,9 +20575,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RatingControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -23084,9 +20600,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23111,9 +20625,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); } /// @@ -23138,9 +20650,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23148,9 +20658,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RefreshStateChanged += x, x => _data.RefreshStateChanged -= x); + }, x => _data.RefreshStateChanged += x, x => _data.RefreshStateChanged -= x); } /// @@ -23175,9 +20683,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23185,9 +20691,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLinkChanged += x, x => _data.ContentLinkChanged -= x); + }, x => _data.ContentLinkChanged += x, x => _data.ContentLinkChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23195,9 +20699,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLinkInvoked += x, x => _data.ContentLinkInvoked -= x); + }, x => _data.ContentLinkInvoked += x, x => _data.ContentLinkInvoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23205,9 +20707,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23215,9 +20715,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23225,9 +20723,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23235,9 +20731,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paste += x, x => _data.Paste -= x); + }, x => _data.Paste += x, x => _data.Paste -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23245,9 +20739,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23255,9 +20747,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23265,9 +20755,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23275,9 +20763,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextChanging += x, x => _data.TextChanging -= x); + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23285,9 +20771,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23295,9 +20779,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23305,9 +20787,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); } /// @@ -23332,9 +20812,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23342,9 +20820,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23352,9 +20828,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -23379,9 +20853,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); } /// @@ -23406,9 +20878,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23433,9 +20903,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23443,9 +20911,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23453,9 +20919,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23463,9 +20927,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23473,9 +20935,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23483,9 +20943,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23493,9 +20951,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23503,9 +20959,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23513,9 +20967,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -23540,9 +20992,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AnchorRequested += x, x => _data.AnchorRequested -= x); + }, x => _data.AnchorRequested += x, x => _data.AnchorRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23550,9 +21000,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DirectManipulationCompleted += x, x => _data.DirectManipulationCompleted -= x); + }, x => _data.DirectManipulationCompleted += x, x => _data.DirectManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23560,9 +21008,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DirectManipulationStarted += x, x => _data.DirectManipulationStarted -= x); + }, x => _data.DirectManipulationStarted += x, x => _data.DirectManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23570,9 +21016,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChanged += x, x => _data.ViewChanged -= x); + }, x => _data.ViewChanged += x, x => _data.ViewChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23580,9 +21024,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChanging += x, x => _data.ViewChanging -= x); + }, x => _data.ViewChanging += x, x => _data.ViewChanging -= x); } /// @@ -23607,9 +21049,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrepareForFocusOnKeyboardInput += x, x => _data.PrepareForFocusOnKeyboardInput -= x); + }, x => _data.PrepareForFocusOnKeyboardInput += x, x => _data.PrepareForFocusOnKeyboardInput -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23617,9 +21057,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QueryChanged += x, x => _data.QueryChanged -= x); + }, x => _data.QueryChanged += x, x => _data.QueryChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23627,9 +21065,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23637,9 +21073,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); + }, x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23647,9 +21081,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); + }, x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); } /// @@ -23674,9 +21106,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChangeCompleted += x, x => _data.ViewChangeCompleted -= x); + }, x => _data.ViewChangeCompleted += x, x => _data.ViewChangeCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23684,9 +21114,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChangeStarted += x, x => _data.ViewChangeStarted -= x); + }, x => _data.ViewChangeStarted += x, x => _data.ViewChangeStarted -= x); } /// @@ -23711,9 +21139,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.BackClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackClick += x, x => _data.BackClick -= x); + }, x => _data.BackClick += x, x => _data.BackClick -= x); } /// @@ -23738,9 +21164,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, int e) => eventHandler(e); return Handler; - } - - , x => _data.IndexClicked += x, x => _data.IndexClicked -= x); + }, x => _data.IndexClicked += x, x => _data.IndexClicked -= x); } /// @@ -23765,9 +21189,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -23792,9 +21214,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23802,9 +21222,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23812,9 +21230,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23822,9 +21238,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); } /// @@ -23849,9 +21263,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23859,9 +21271,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -23886,9 +21296,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompositionScaleChanged += x, x => _data.CompositionScaleChanged -= x); + }, x => _data.CompositionScaleChanged += x, x => _data.CompositionScaleChanged -= x); } /// @@ -23913,9 +21321,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23923,9 +21329,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -23950,9 +21354,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23977,9 +21379,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23987,9 +21387,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23997,9 +21395,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -24024,9 +21420,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BeforeTextChanging += x, x => _data.BeforeTextChanging -= x); + }, x => _data.BeforeTextChanging += x, x => _data.BeforeTextChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24034,9 +21428,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24044,9 +21436,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24054,9 +21444,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24064,9 +21452,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24074,9 +21460,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paste += x, x => _data.Paste -= x); + }, x => _data.Paste += x, x => _data.Paste -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24084,9 +21468,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24094,9 +21476,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24104,9 +21484,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24114,9 +21492,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextChanging += x, x => _data.TextChanging -= x); + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24124,9 +21500,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24134,9 +21508,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24144,9 +21516,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); } /// @@ -24171,9 +21541,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24181,9 +21549,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24191,9 +21557,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24201,9 +21565,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24211,9 +21573,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24221,9 +21581,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24231,9 +21589,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24241,9 +21597,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24251,9 +21605,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -24278,9 +21630,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24305,9 +21655,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedTimeChanged += x, x => _data.SelectedTimeChanged -= x); + }, x => _data.SelectedTimeChanged += x, x => _data.SelectedTimeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24315,9 +21663,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TimeChanged += x, x => _data.TimeChanged -= x); + }, x => _data.TimeChanged += x, x => _data.TimeChanged -= x); } /// @@ -24342,9 +21688,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimePicked += x, x => _data.TimePicked -= x); + }, x => _data.TimePicked += x, x => _data.TimePicked -= x); } /// @@ -24369,9 +21713,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsCheckedChanged += x, x => _data.IsCheckedChanged -= x); + }, x => _data.IsCheckedChanged += x, x => _data.IsCheckedChanged -= x); } /// @@ -24396,9 +21738,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -24423,9 +21763,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24433,9 +21771,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -24460,9 +21796,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Collapsed += x, x => _data.Collapsed -= x); + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24470,9 +21804,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24480,9 +21812,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24490,9 +21820,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Expanding += x, x => _data.Expanding -= x); + }, x => _data.Expanding += x, x => _data.Expanding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24500,9 +21828,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); } /// @@ -24527,9 +21853,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24554,9 +21878,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24581,9 +21903,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24591,9 +21911,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24601,9 +21919,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -24628,9 +21944,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CleanUpVirtualizedItemEvent += x, x => _data.CleanUpVirtualizedItemEvent -= x); + }, x => _data.CleanUpVirtualizedItemEvent += x, x => _data.CleanUpVirtualizedItemEvent -= x); } /// @@ -24655,9 +21969,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24665,9 +21977,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24675,9 +21985,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24685,9 +21993,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24695,9 +22001,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24705,9 +22009,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24715,9 +22017,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24725,9 +22025,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24735,9 +22033,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24745,9 +22041,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24755,9 +22049,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.WebViewNavigationFailedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24765,9 +22057,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24775,9 +22065,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24785,9 +22073,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24795,9 +22081,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.NotifyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24805,9 +22089,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeparateProcessLost += x, x => _data.SeparateProcessLost -= x); + }, x => _data.SeparateProcessLost += x, x => _data.SeparateProcessLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24815,9 +22097,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24825,9 +22105,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24835,9 +22113,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24845,9 +22121,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } } @@ -24954,9 +22228,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); } /// @@ -24981,9 +22253,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UriRequested += x, x => _data.UriRequested -= x); + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); } /// @@ -25008,9 +22278,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UriRequested += x, x => _data.UriRequested -= x); + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); } /// @@ -25035,9 +22303,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25062,9 +22328,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActualCameraChanged += x, x => _data.ActualCameraChanged -= x); + }, x => _data.ActualCameraChanged += x, x => _data.ActualCameraChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25072,9 +22336,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActualCameraChanging += x, x => _data.ActualCameraChanging -= x); + }, x => _data.ActualCameraChanging += x, x => _data.ActualCameraChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25082,9 +22344,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CenterChanged += x, x => _data.CenterChanged -= x); + }, x => _data.CenterChanged += x, x => _data.CenterChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25092,9 +22352,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CustomExperienceChanged += x, x => _data.CustomExperienceChanged -= x); + }, x => _data.CustomExperienceChanged += x, x => _data.CustomExperienceChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25102,9 +22360,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadingChanged += x, x => _data.HeadingChanged -= x); + }, x => _data.HeadingChanged += x, x => _data.HeadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25112,9 +22368,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoadingStatusChanged += x, x => _data.LoadingStatusChanged -= x); + }, x => _data.LoadingStatusChanged += x, x => _data.LoadingStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25122,9 +22376,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25132,9 +22384,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapDoubleTapped += x, x => _data.MapDoubleTapped -= x); + }, x => _data.MapDoubleTapped += x, x => _data.MapDoubleTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25142,9 +22392,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25152,9 +22400,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25162,9 +22408,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25172,9 +22416,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapHolding += x, x => _data.MapHolding -= x); + }, x => _data.MapHolding += x, x => _data.MapHolding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25182,9 +22424,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapRightTapped += x, x => _data.MapRightTapped -= x); + }, x => _data.MapRightTapped += x, x => _data.MapRightTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25192,9 +22432,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapTapped += x, x => _data.MapTapped -= x); + }, x => _data.MapTapped += x, x => _data.MapTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25202,9 +22440,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PitchChanged += x, x => _data.PitchChanged -= x); + }, x => _data.PitchChanged += x, x => _data.PitchChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25212,9 +22448,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25222,9 +22456,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TransformOriginChanged += x, x => _data.TransformOriginChanged -= x); + }, x => _data.TransformOriginChanged += x, x => _data.TransformOriginChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25232,9 +22464,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ZoomLevelChanged += x, x => _data.ZoomLevelChanged -= x); + }, x => _data.ZoomLevelChanged += x, x => _data.ZoomLevelChanged -= x); } /// @@ -25259,9 +22489,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25286,9 +22514,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25313,9 +22539,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25323,9 +22547,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25333,9 +22555,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25343,9 +22563,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); } /// @@ -25370,9 +22588,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25397,9 +22613,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25424,9 +22638,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25451,9 +22663,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25478,9 +22688,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25505,9 +22713,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25515,9 +22721,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); } /// @@ -25542,9 +22746,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25569,9 +22771,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25596,9 +22796,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25623,9 +22821,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -25796,9 +22992,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25823,9 +23017,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25850,9 +23042,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25877,9 +23067,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -25904,9 +23092,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25931,9 +23117,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25941,9 +23125,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -25968,9 +23150,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); } /// @@ -25995,9 +23175,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26022,9 +23200,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26049,9 +23225,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26076,9 +23250,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26086,9 +23258,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26096,9 +23266,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26106,9 +23274,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26116,9 +23282,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opening += x, x => _data.Opening -= x); + }, x => _data.Opening += x, x => _data.Opening -= x); } /// @@ -26143,9 +23307,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26170,9 +23332,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26180,9 +23340,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -26207,9 +23365,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26234,9 +23390,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26261,9 +23415,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26288,9 +23440,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -26315,9 +23465,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26325,9 +23473,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -26352,9 +23498,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26379,9 +23523,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26406,9 +23548,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26416,9 +23556,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -26443,9 +23581,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26453,9 +23589,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -26480,9 +23614,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26490,9 +23622,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -26517,9 +23647,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26544,9 +23672,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26571,9 +23697,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -26598,9 +23722,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scroll += x, x => _data.Scroll -= x); + }, x => _data.Scroll += x, x => _data.Scroll -= x); } /// @@ -26625,9 +23747,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -26652,9 +23772,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26679,9 +23797,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26706,9 +23822,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26716,9 +23830,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragDelta += x, x => _data.DragDelta -= x); + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26726,9 +23838,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); } /// @@ -26753,9 +23863,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Checked += x, x => _data.Checked -= x); + }, x => _data.Checked += x, x => _data.Checked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26763,9 +23871,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26773,9 +23879,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unchecked += x, x => _data.Unchecked -= x); + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); } /// @@ -26800,9 +23904,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26827,9 +23929,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -26880,9 +23980,7 @@ namespace Windows.UI.Xaml.Data { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26907,9 +24005,7 @@ namespace Windows.UI.Xaml.Data { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26934,9 +24030,7 @@ namespace Windows.UI.Xaml.Data { void Handler(object sender, object instance) => eventHandler(instance); return Handler; - } - - , x => _data.ElementInstanceChanged += x, x => _data.ElementInstanceChanged -= x); + }, x => _data.ElementInstanceChanged += x, x => _data.ElementInstanceChanged -= x); } /// @@ -26961,9 +24055,7 @@ namespace Windows.UI.Xaml.Data { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26971,9 +24063,7 @@ namespace Windows.UI.Xaml.Data { void Handler(object sender, global::Windows.UI.Xaml.Data.CurrentChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); } } @@ -27028,9 +24118,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27038,9 +24126,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27048,9 +24134,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); } /// @@ -27075,9 +24159,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27102,9 +24184,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27112,9 +24192,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27122,9 +24200,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); } /// @@ -27149,9 +24225,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27159,9 +24233,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27169,9 +24241,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27179,9 +24249,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27206,9 +24274,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -27259,9 +24325,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27286,9 +24350,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27313,9 +24375,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27323,9 +24383,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -27350,9 +24408,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27360,9 +24416,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CanExecuteRequested += x, x => _data.CanExecuteRequested -= x); + }, x => _data.CanExecuteRequested += x, x => _data.CanExecuteRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27370,9 +24424,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27380,9 +24432,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ExecuteRequested += x, x => _data.ExecuteRequested -= x); + }, x => _data.ExecuteRequested += x, x => _data.ExecuteRequested -= x); } } @@ -27421,9 +24471,7 @@ namespace Windows.UI.Xaml.Interop { void Handler(global::Windows.UI.Xaml.Interop.IBindableObservableVector vector, object e) => eventHandler((vector, e)); return Handler; - } - - , x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); } } @@ -27510,9 +24558,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27537,9 +24583,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27564,9 +24608,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27591,9 +24633,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27618,9 +24658,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27645,9 +24683,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27655,9 +24691,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); } /// @@ -27682,9 +24716,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27709,9 +24741,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); } /// @@ -27736,9 +24766,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27763,9 +24791,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27790,9 +24816,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27817,9 +24841,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27844,9 +24866,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -27921,9 +24941,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27948,9 +24966,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -27975,9 +24991,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -28002,9 +25016,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -28029,9 +25041,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -28056,9 +25066,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -28083,9 +25091,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -28110,9 +25116,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -28137,9 +25141,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28147,9 +25149,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -28174,9 +25174,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -28219,9 +25217,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(object sender, global::Windows.UI.Xaml.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28229,9 +25225,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28239,9 +25233,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); } /// @@ -28266,9 +25258,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28276,9 +25266,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); } } @@ -28317,9 +25305,7 @@ namespace Windows.UI.Xaml.Media.Media3D { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -28358,9 +25344,7 @@ namespace Windows.UI.Xaml.Navigation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -28399,9 +25383,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(object sender, global::Windows.UI.Xaml.Printing.AddPagesEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AddPages += x, x => _data.AddPages -= x); + }, x => _data.AddPages += x, x => _data.AddPages -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28409,9 +25391,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28419,9 +25399,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(object sender, global::Windows.UI.Xaml.Printing.GetPreviewPageEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GetPreviewPage += x, x => _data.GetPreviewPage -= x); + }, x => _data.GetPreviewPage += x, x => _data.GetPreviewPage -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28429,9 +25407,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(object sender, global::Windows.UI.Xaml.Printing.PaginateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paginate += x, x => _data.Paginate -= x); + }, x => _data.Paginate += x, x => _data.Paginate -= x); } } @@ -28470,9 +25446,7 @@ namespace Windows.Web.Http.Filters { void Handler(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); } } @@ -28511,9 +25485,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28521,9 +25493,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28531,9 +25501,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28541,9 +25509,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28551,9 +25517,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28561,9 +25525,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28571,9 +25533,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28581,9 +25541,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28591,9 +25549,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28601,9 +25557,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28611,9 +25565,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28621,9 +25573,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28631,9 +25581,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28641,9 +25589,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28651,9 +25597,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28661,9 +25605,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28671,9 +25613,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } } @@ -28716,9 +25656,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyPressed += x, x => _data.AcceleratorKeyPressed -= x); + }, x => _data.AcceleratorKeyPressed += x, x => _data.AcceleratorKeyPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28726,9 +25664,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28736,9 +25672,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28746,9 +25680,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28756,9 +25688,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28766,9 +25696,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28776,9 +25704,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28786,9 +25712,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28796,9 +25720,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28806,9 +25728,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28816,9 +25736,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28826,9 +25744,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MoveFocusRequested += x, x => _data.MoveFocusRequested -= x); + }, x => _data.MoveFocusRequested += x, x => _data.MoveFocusRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28836,9 +25752,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28846,9 +25760,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28856,9 +25768,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28866,9 +25776,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28876,9 +25784,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28886,9 +25792,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28896,9 +25800,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28906,9 +25808,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28916,9 +25816,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } /// @@ -28943,9 +25841,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProcessExited += x, x => _data.ProcessExited -= x); + }, x => _data.ProcessExited += x, x => _data.ProcessExited -= x); } } @@ -28963,9 +25859,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.CurrentActivityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Uno.UI.BaseActivity.CurrentChanged += x, x => global::Uno.UI.BaseActivity.CurrentChanged -= x); + }, x => global::Uno.UI.BaseActivity.CurrentChanged += x, x => global::Uno.UI.BaseActivity.CurrentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28973,9 +25867,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.ActivitiesCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Uno.UI.BaseActivity.InstancesChanged += x, x => global::Uno.UI.BaseActivity.InstancesChanged -= x); + }, x => global::Uno.UI.BaseActivity.InstancesChanged += x, x => global::Uno.UI.BaseActivity.InstancesChanged -= x); } } @@ -28993,9 +25885,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged += x, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged -= x); + }, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged += x, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged -= x); } } @@ -29013,9 +25903,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated += x, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated += x, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29023,9 +25911,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29033,9 +25919,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29043,9 +25927,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29053,9 +25935,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29063,9 +25943,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29073,9 +25951,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected += x, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected += x, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected -= x); } } @@ -29093,9 +25969,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29103,9 +25977,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, global::Windows.ApplicationModel.DataTransfer.ClipboardHistoryChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29113,9 +25985,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29123,9 +25993,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged -= x); } } @@ -29143,9 +26011,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(object sender, global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged += x, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged -= x); + }, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged += x, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged -= x); } } @@ -29163,9 +26029,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded -= x); + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29173,9 +26037,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved -= x); + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29183,9 +26045,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded -= x); + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29193,9 +26053,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved -= x); + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29203,9 +26061,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.Gamepad.GamepadAdded += x, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded -= x); + }, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded += x, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29213,9 +26069,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved += x, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved -= x); + }, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved += x, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29223,9 +26077,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded -= x); + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29233,9 +26085,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved -= x); + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29243,9 +26093,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded -= x); + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29253,9 +26101,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved -= x); + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29263,9 +26109,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded -= x); + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29273,9 +26117,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved -= x); + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved -= x); } } @@ -29293,9 +26135,7 @@ namespace Windows.Gaming.UI { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged += x, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged -= x); + }, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged += x, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29303,9 +26143,7 @@ namespace Windows.Gaming.UI { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.UI.GameBar.VisibilityChanged += x, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged -= x); + }, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged += x, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged -= x); } } @@ -29323,9 +26161,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated -= x); + }, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29333,9 +26169,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29343,9 +26177,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29353,9 +26185,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29363,9 +26193,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29373,9 +26201,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged -= x); } } @@ -29393,9 +26219,7 @@ namespace Windows.Graphics.Holographic { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged += x, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged -= x); + }, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged += x, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged -= x); } } @@ -29413,9 +26237,7 @@ namespace Windows.Media.Core.Preview { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged += x, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged -= x); + }, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged += x, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged -= x); } } @@ -29433,9 +26255,7 @@ namespace Windows.Media.Devices { void Handler(object sender, global::Windows.Media.Devices.DefaultAudioCaptureDeviceChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged -= x); + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29443,9 +26263,7 @@ namespace Windows.Media.Devices { void Handler(object sender, global::Windows.Media.Devices.DefaultAudioRenderDeviceChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged -= x); + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged -= x); } } @@ -29463,9 +26281,7 @@ namespace Windows.Media.Playback { void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground -= x); + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29473,9 +26289,7 @@ namespace Windows.Media.Playback { void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground -= x); + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground -= x); } } @@ -29493,9 +26307,7 @@ namespace Windows.Networking.Connectivity { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged += x, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged -= x); + }, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged += x, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged -= x); } } @@ -29513,9 +26325,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged += x, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged -= x); + }, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged += x, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged -= x); } } @@ -29533,9 +26343,7 @@ namespace Windows.Networking.Proximity { void Handler(object sender, global::Windows.Networking.Proximity.ConnectionRequestedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested += x, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested -= x); + }, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested += x, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29543,9 +26351,7 @@ namespace Windows.Networking.Proximity { void Handler(object sender, global::Windows.Networking.Proximity.TriggeredConnectionStateChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged += x, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged -= x); + }, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged += x, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged -= x); } } @@ -29563,9 +26369,7 @@ namespace Windows.Perception.Spatial { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged += x, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged -= x); + }, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged += x, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged -= x); } } @@ -29583,9 +26387,7 @@ namespace Windows.Phone.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged += x, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged -= x); + }, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged += x, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged -= x); } } @@ -29603,9 +26405,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.BackPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29613,9 +26413,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29623,9 +26421,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29633,9 +26429,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased -= x); } } @@ -29653,9 +26447,7 @@ namespace Windows.Security.Authentication.Identity.Provider { void Handler(object sender, global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged += x, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged -= x); + }, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged += x, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged -= x); } } @@ -29673,9 +26465,7 @@ namespace Windows.System { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased -= x); + }, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29683,9 +26473,7 @@ namespace Windows.System { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased -= x); + }, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29693,9 +26481,7 @@ namespace Windows.System { void Handler(object sender, global::Windows.System.AppMemoryUsageLimitChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging += x, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging -= x); + }, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging += x, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29703,9 +26489,7 @@ namespace Windows.System { void Handler(object sender, global::Windows.System.UserDeviceAssociationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged += x, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged -= x); + }, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged += x, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged -= x); } } @@ -29723,9 +26507,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased -= x); + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29733,9 +26515,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29743,9 +26523,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased -= x); + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29753,9 +26531,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29763,9 +26539,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.BatteryStatusChanged += x, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged -= x); + }, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged += x, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29773,9 +26547,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged += x, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged -= x); + }, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged += x, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29783,9 +26555,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged += x, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged -= x); + }, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged += x, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29793,9 +26563,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged += x, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged -= x); + }, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged += x, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29803,9 +26571,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged += x, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged -= x); + }, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged += x, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged -= x); } } @@ -29823,9 +26589,7 @@ namespace Windows.System.Profile { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged += x, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged -= x); + }, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged += x, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29833,9 +26597,7 @@ namespace Windows.System.Profile { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged += x, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged -= x); + }, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged += x, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29843,9 +26605,7 @@ namespace Windows.System.Profile { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged += x, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged -= x); + }, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged += x, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged -= x); } } @@ -29863,9 +26623,7 @@ namespace Windows.UI.ViewManagement { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged += x, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged -= x); + }, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged += x, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged -= x); } } @@ -29883,9 +26641,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs eventArgs) => eventHandler(eventArgs); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Activated += x, x => global::Windows.UI.WebUI.WebUIApplication.Activated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Activated += x, x => global::Windows.UI.WebUI.WebUIApplication.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29893,9 +26649,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs eventArgs) => eventHandler(eventArgs); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated += x, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated += x, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29903,9 +26657,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.IEnteredBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29913,9 +26665,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.ILeavingBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29923,9 +26673,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.UI.WebUI.IWebUINavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Navigated += x, x => global::Windows.UI.WebUI.WebUIApplication.Navigated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Navigated += x, x => global::Windows.UI.WebUI.WebUIApplication.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29933,9 +26681,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.UI.WebUI.NewWebUIViewCreatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated += x, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated += x, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29943,9 +26689,7 @@ namespace Windows.UI.WebUI { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Resuming += x, x => global::Windows.UI.WebUI.WebUIApplication.Resuming -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Resuming += x, x => global::Windows.UI.WebUI.WebUIApplication.Resuming -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29953,9 +26697,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.ISuspendingEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Suspending += x, x => global::Windows.UI.WebUI.WebUIApplication.Suspending -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Suspending += x, x => global::Windows.UI.WebUI.WebUIApplication.Suspending -= x); } } @@ -29973,9 +26715,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, object args) => eventHandler(args); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged += x, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged -= x); + }, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged += x, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29983,9 +26723,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29993,9 +26731,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerGotFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -30003,9 +26739,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -30013,9 +26747,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerLostFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus -= x); } } @@ -30033,9 +26765,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, global::Windows.UI.Xaml.Media.RenderedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered -= x); + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -30043,9 +26773,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering -= x); + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -30053,8 +26781,6 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost -= x); + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.monoandroid90.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.monoandroid90.approved.txt index a76ba89..3bdec4c 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.monoandroid90.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.monoandroid90.approved.txt @@ -40,9 +40,7 @@ namespace Android.Support.V4.View { void Handler(object sender, global::Android.Support.V4.View.ViewPager.AdapterChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AdapterChange += x, x => _data.AdapterChange -= x); + }, x => _data.AdapterChange += x, x => _data.AdapterChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -50,9 +48,7 @@ namespace Android.Support.V4.View { void Handler(object sender, global::Android.Support.V4.View.ViewPager.PageScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PageScrolled += x, x => _data.PageScrolled -= x); + }, x => _data.PageScrolled += x, x => _data.PageScrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -60,9 +56,7 @@ namespace Android.Support.V4.View { void Handler(object sender, global::Android.Support.V4.View.ViewPager.PageScrollStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PageScrollStateChanged += x, x => _data.PageScrollStateChanged -= x); + }, x => _data.PageScrollStateChanged += x, x => _data.PageScrollStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -70,9 +64,7 @@ namespace Android.Support.V4.View { void Handler(object sender, global::Android.Support.V4.View.ViewPager.PageSelectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PageSelected += x, x => _data.PageSelected -= x); + }, x => _data.PageSelected += x, x => _data.PageSelected -= x); } } @@ -111,9 +103,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); + }, x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -121,9 +111,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); + }, x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -131,9 +119,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); + }, x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -141,9 +127,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); + }, x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); } } @@ -182,9 +166,7 @@ namespace Android.Support.V7.Widget { void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewAttachedToWindow += x, x => _data.ChildViewAttachedToWindow -= x); + }, x => _data.ChildViewAttachedToWindow += x, x => _data.ChildViewAttachedToWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -192,9 +174,7 @@ namespace Android.Support.V7.Widget { void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewDetachedFromWindow += x, x => _data.ChildViewDetachedFromWindow -= x); + }, x => _data.ChildViewDetachedFromWindow += x, x => _data.ChildViewDetachedFromWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -202,9 +182,7 @@ namespace Android.Support.V7.Widget { void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InterceptTouchEvent += x, x => _data.InterceptTouchEvent -= x); + }, x => _data.InterceptTouchEvent += x, x => _data.InterceptTouchEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -212,9 +190,7 @@ namespace Android.Support.V7.Widget { void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RecyclerEvent += x, x => _data.RecyclerEvent -= x); + }, x => _data.RecyclerEvent += x, x => _data.RecyclerEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -222,9 +198,7 @@ namespace Android.Support.V7.Widget { void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RequestDisallowInterceptTouchEvent += x, x => _data.RequestDisallowInterceptTouchEvent -= x); + }, x => _data.RequestDisallowInterceptTouchEvent += x, x => _data.RequestDisallowInterceptTouchEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -232,9 +206,7 @@ namespace Android.Support.V7.Widget { void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); + }, x => _data.TouchEvent += x, x => _data.TouchEvent -= x); } } @@ -277,9 +249,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); + }, x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -287,9 +257,7 @@ namespace Android.Views { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -297,9 +265,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); + }, x => _data.ContextClick += x, x => _data.ContextClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -307,9 +273,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); + }, x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -317,9 +281,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); + }, x => _data.Drag += x, x => _data.Drag -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -327,9 +289,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); + }, x => _data.FocusChange += x, x => _data.FocusChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -337,9 +297,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); + }, x => _data.GenericMotion += x, x => _data.GenericMotion -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -347,9 +305,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); + }, x => _data.Hover += x, x => _data.Hover -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -357,9 +313,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -367,9 +321,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); + }, x => _data.LayoutChange += x, x => _data.LayoutChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -377,9 +329,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); + }, x => _data.LongClick += x, x => _data.LongClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -387,9 +337,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); + }, x => _data.ScrollChange += x, x => _data.ScrollChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -397,9 +345,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); + }, x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -407,9 +353,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); + }, x => _data.Touch += x, x => _data.Touch -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -417,9 +361,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.UnhandledKeyEventEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UnhandledKeyEvent += x, x => _data.UnhandledKeyEvent -= x); + }, x => _data.UnhandledKeyEvent += x, x => _data.UnhandledKeyEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -427,9 +369,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); + }, x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -437,9 +377,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); + }, x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); } /// @@ -464,9 +402,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); + }, x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -474,9 +410,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); + }, x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -484,9 +418,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); + }, x => _data.AnimationStart += x, x => _data.AnimationStart -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -494,9 +426,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); + }, x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -504,9 +434,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); + }, x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); } } @@ -565,9 +493,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.AbsListView.RecyclerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Recycler += x, x => _data.Recycler -= x); + }, x => _data.Recycler += x, x => _data.Recycler -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -575,9 +501,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.AbsListView.ScrollEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scroll += x, x => _data.Scroll -= x); + }, x => _data.Scroll += x, x => _data.Scroll -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -585,9 +509,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.AbsListView.ScrollStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollStateChanged += x, x => _data.ScrollStateChanged -= x); + }, x => _data.ScrollStateChanged += x, x => _data.ScrollStateChanged -= x); } /// @@ -612,9 +534,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.AdapterView.ItemClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemClick += x, x => _data.ItemClick -= x); + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -622,9 +542,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.AdapterView.ItemLongClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongClick += x, x => _data.ItemLongClick -= x); + }, x => _data.ItemLongClick += x, x => _data.ItemLongClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -632,9 +550,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.AdapterView.ItemSelectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -643,9 +559,7 @@ namespace Android.Widget { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelectionCleared += x, x => _data.ItemSelectionCleared -= x); + }, x => _data.ItemSelectionCleared += x, x => _data.ItemSelectionCleared -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -653,9 +567,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.AdapterView.NothingSelectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NothingSelected += x, x => _data.NothingSelected -= x); + }, x => _data.NothingSelected += x, x => _data.NothingSelected -= x); } /// @@ -680,9 +592,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.CompoundButton.CheckedChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChange += x, x => _data.CheckedChange -= x); + }, x => _data.CheckedChange += x, x => _data.CheckedChange -= x); } /// @@ -707,9 +617,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SearchView.CloseEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Close += x, x => _data.Close -= x); + }, x => _data.Close += x, x => _data.Close -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -717,9 +625,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SearchView.QueryTextChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.QueryTextChange += x, x => _data.QueryTextChange -= x); + }, x => _data.QueryTextChange += x, x => _data.QueryTextChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -727,9 +633,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.QueryTextFocusChange += x, x => _data.QueryTextFocusChange -= x); + }, x => _data.QueryTextFocusChange += x, x => _data.QueryTextFocusChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -737,9 +641,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SearchView.QueryTextSubmitEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.QueryTextSubmit += x, x => _data.QueryTextSubmit -= x); + }, x => _data.QueryTextSubmit += x, x => _data.QueryTextSubmit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -747,9 +649,7 @@ namespace Android.Widget { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchClick += x, x => _data.SearchClick -= x); + }, x => _data.SearchClick += x, x => _data.SearchClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -757,9 +657,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SearchView.SuggestionClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SuggestionClick += x, x => _data.SuggestionClick -= x); + }, x => _data.SuggestionClick += x, x => _data.SuggestionClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -767,9 +665,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SearchView.SuggestionSelectEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SuggestionSelect += x, x => _data.SuggestionSelect -= x); + }, x => _data.SuggestionSelect += x, x => _data.SuggestionSelect -= x); } /// @@ -794,9 +690,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SeekBar.ProgressChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); + }, x => _data.ProgressChanged += x, x => _data.ProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -804,9 +698,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SeekBar.StartTrackingTouchEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StartTrackingTouch += x, x => _data.StartTrackingTouch -= x); + }, x => _data.StartTrackingTouch += x, x => _data.StartTrackingTouch -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -814,9 +706,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.SeekBar.StopTrackingTouchEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StopTrackingTouch += x, x => _data.StopTrackingTouch -= x); + }, x => _data.StopTrackingTouch += x, x => _data.StopTrackingTouch -= x); } /// @@ -841,9 +731,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); + }, x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -851,9 +739,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); + }, x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -861,9 +747,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); + }, x => _data.EditorAction += x, x => _data.EditorAction -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -871,9 +755,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } } @@ -916,9 +798,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.ActionMode e) => eventHandler(e); return Handler; - } - - , x => _data.ActionModeFinished += x, x => _data.ActionModeFinished -= x); + }, x => _data.ActionModeFinished += x, x => _data.ActionModeFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -926,9 +806,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.ActionMode e) => eventHandler(e); return Handler; - } - - , x => _data.ActionModeStarted += x, x => _data.ActionModeStarted -= x); + }, x => _data.ActionModeStarted += x, x => _data.ActionModeStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -936,9 +814,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.ActivityReenterEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ActivityReenter += x, x => _data.ActivityReenter -= x); + }, x => _data.ActivityReenter += x, x => _data.ActivityReenter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -946,9 +822,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.ActivityResultEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ActivityResult += x, x => _data.ActivityResult -= x); + }, x => _data.ActivityResult += x, x => _data.ActivityResult -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -956,9 +830,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AttachedToWindow += x, x => _data.AttachedToWindow -= x); + }, x => _data.AttachedToWindow += x, x => _data.AttachedToWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -966,9 +838,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.App.Fragment e) => eventHandler(e); return Handler; - } - - , x => _data.AttachFragment += x, x => _data.AttachFragment -= x); + }, x => _data.AttachFragment += x, x => _data.AttachFragment -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -976,9 +846,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackPressed += x, x => _data.BackPressed -= x); + }, x => _data.BackPressed += x, x => _data.BackPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -986,9 +854,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.ChildTitleChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildTitleChanged += x, x => _data.ChildTitleChanged -= x); + }, x => _data.ChildTitleChanged += x, x => _data.ChildTitleChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -996,9 +862,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Content.Res.Configuration e) => eventHandler(e); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1006,9 +870,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContentChanged += x, x => _data.ContentChanged -= x); + }, x => _data.ContentChanged += x, x => _data.ContentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1016,9 +878,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.IMenuItem e) => eventHandler(e); return Handler; - } - - , x => _data.ContextItemSelected += x, x => _data.ContextItemSelected -= x); + }, x => _data.ContextItemSelected += x, x => _data.ContextItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1026,9 +886,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.IMenu e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuClosed += x, x => _data.ContextMenuClosed -= x); + }, x => _data.ContextMenuClosed += x, x => _data.ContextMenuClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1036,9 +894,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.OS.Bundle e) => eventHandler(e); return Handler; - } - - , x => _data.Create += x, x => _data.Create -= x); + }, x => _data.Create += x, x => _data.Create -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1046,9 +902,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.CreateContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CreateContextMenu += x, x => _data.CreateContextMenu -= x); + }, x => _data.CreateContextMenu += x, x => _data.CreateContextMenu -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1056,9 +910,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CreateDescriptionFormatted += x, x => _data.CreateDescriptionFormatted -= x); + }, x => _data.CreateDescriptionFormatted += x, x => _data.CreateDescriptionFormatted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1066,9 +918,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.App.TaskStackBuilder e) => eventHandler(e); return Handler; - } - - , x => _data.CreateNavigateUpTaskStack += x, x => _data.CreateNavigateUpTaskStack -= x); + }, x => _data.CreateNavigateUpTaskStack += x, x => _data.CreateNavigateUpTaskStack -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1076,9 +926,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.IMenu e) => eventHandler(e); return Handler; - } - - , x => _data.CreateOptionsMenu += x, x => _data.CreateOptionsMenu -= x); + }, x => _data.CreateOptionsMenu += x, x => _data.CreateOptionsMenu -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1086,9 +934,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.CreatePanelMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CreatePanelMenu += x, x => _data.CreatePanelMenu -= x); + }, x => _data.CreatePanelMenu += x, x => _data.CreatePanelMenu -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1096,9 +942,7 @@ namespace Uno.UI { void Handler(object sender, int e) => eventHandler(e); return Handler; - } - - , x => _data.CreatePanelView += x, x => _data.CreatePanelView -= x); + }, x => _data.CreatePanelView += x, x => _data.CreatePanelView -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1106,9 +950,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.CreateThumbnailEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CreateThumbnail += x, x => _data.CreateThumbnail -= x); + }, x => _data.CreateThumbnail += x, x => _data.CreateThumbnail -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1116,9 +958,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.CreateViewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CreateView += x, x => _data.CreateView -= x); + }, x => _data.CreateView += x, x => _data.CreateView -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1126,9 +966,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.CreateViewWithParentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CreateViewWithParent += x, x => _data.CreateViewWithParent -= x); + }, x => _data.CreateViewWithParent += x, x => _data.CreateViewWithParent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1136,9 +974,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.CreateWithPersistedStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CreateWithPersistedState += x, x => _data.CreateWithPersistedState -= x); + }, x => _data.CreateWithPersistedState += x, x => _data.CreateWithPersistedState -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1146,9 +982,7 @@ namespace Uno.UI { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1156,9 +990,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Destroy += x, x => _data.Destroy -= x); + }, x => _data.Destroy += x, x => _data.Destroy -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1166,9 +998,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DetachedFromWindow += x, x => _data.DetachedFromWindow -= x); + }, x => _data.DetachedFromWindow += x, x => _data.DetachedFromWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1176,9 +1006,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EnterAnimationComplete += x, x => _data.EnterAnimationComplete -= x); + }, x => _data.EnterAnimationComplete += x, x => _data.EnterAnimationComplete -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1186,9 +1014,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.MotionEvent e) => eventHandler(e); return Handler; - } - - , x => _data.GenericMotionEvent += x, x => _data.GenericMotionEvent -= x); + }, x => _data.GenericMotionEvent += x, x => _data.GenericMotionEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1196,9 +1022,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.KeyDownEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1206,9 +1030,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.KeyLongPressEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyLongPress += x, x => _data.KeyLongPress -= x); + }, x => _data.KeyLongPress += x, x => _data.KeyLongPress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1216,9 +1038,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.KeyMultipleEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyMultiple += x, x => _data.KeyMultiple -= x); + }, x => _data.KeyMultiple += x, x => _data.KeyMultiple -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1226,9 +1046,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.KeyShortcutEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyShortcut += x, x => _data.KeyShortcut -= x); + }, x => _data.KeyShortcut += x, x => _data.KeyShortcut -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1236,9 +1054,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.KeyUpEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1246,9 +1062,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LowMemory += x, x => _data.LowMemory -= x); + }, x => _data.LowMemory += x, x => _data.LowMemory -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1256,9 +1070,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.MenuOpenedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MenuOpened += x, x => _data.MenuOpened -= x); + }, x => _data.MenuOpened += x, x => _data.MenuOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1266,9 +1078,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigateUp += x, x => _data.NavigateUp -= x); + }, x => _data.NavigateUp += x, x => _data.NavigateUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1276,9 +1086,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.App.Activity e) => eventHandler(e); return Handler; - } - - , x => _data.NavigateUpFromChild += x, x => _data.NavigateUpFromChild -= x); + }, x => _data.NavigateUpFromChild += x, x => _data.NavigateUpFromChild -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1286,9 +1094,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Content.Intent e) => eventHandler(e); return Handler; - } - - , x => _data.NewIntent += x, x => _data.NewIntent -= x); + }, x => _data.NewIntent += x, x => _data.NewIntent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1296,9 +1102,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.IMenuItem e) => eventHandler(e); return Handler; - } - - , x => _data.OptionsItemSelected += x, x => _data.OptionsItemSelected -= x); + }, x => _data.OptionsItemSelected += x, x => _data.OptionsItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1306,9 +1110,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.IMenu e) => eventHandler(e); return Handler; - } - - , x => _data.OptionsMenuClosed += x, x => _data.OptionsMenuClosed -= x); + }, x => _data.OptionsMenuClosed += x, x => _data.OptionsMenuClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1316,9 +1118,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.PanelClosedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanelClosed += x, x => _data.PanelClosed -= x); + }, x => _data.PanelClosed += x, x => _data.PanelClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1326,9 +1126,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pause += x, x => _data.Pause -= x); + }, x => _data.Pause += x, x => _data.Pause -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1336,9 +1134,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.OS.Bundle e) => eventHandler(e); return Handler; - } - - , x => _data.PostCreate += x, x => _data.PostCreate -= x); + }, x => _data.PostCreate += x, x => _data.PostCreate -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1346,9 +1142,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.PostCreateWithPersistedStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PostCreateWithPersistedState += x, x => _data.PostCreateWithPersistedState -= x); + }, x => _data.PostCreateWithPersistedState += x, x => _data.PostCreateWithPersistedState -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1356,9 +1150,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PostResume += x, x => _data.PostResume -= x); + }, x => _data.PostResume += x, x => _data.PostResume -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1366,9 +1158,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.App.TaskStackBuilder e) => eventHandler(e); return Handler; - } - - , x => _data.PrepareNavigateUpTaskStack += x, x => _data.PrepareNavigateUpTaskStack -= x); + }, x => _data.PrepareNavigateUpTaskStack += x, x => _data.PrepareNavigateUpTaskStack -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1376,9 +1166,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.IMenu e) => eventHandler(e); return Handler; - } - - , x => _data.PrepareOptionsMenu += x, x => _data.PrepareOptionsMenu -= x); + }, x => _data.PrepareOptionsMenu += x, x => _data.PrepareOptionsMenu -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1386,9 +1174,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.PrepareOptionsPanelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PrepareOptionsPanel += x, x => _data.PrepareOptionsPanel -= x); + }, x => _data.PrepareOptionsPanel += x, x => _data.PrepareOptionsPanel -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1396,9 +1182,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.PreparePanelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PreparePanel += x, x => _data.PreparePanel -= x); + }, x => _data.PreparePanel += x, x => _data.PreparePanel -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1406,9 +1190,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.OS.Bundle e) => eventHandler(e); return Handler; - } - - , x => _data.ProvideAssistData += x, x => _data.ProvideAssistData -= x); + }, x => _data.ProvideAssistData += x, x => _data.ProvideAssistData -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1416,9 +1198,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.RequestPermissionsResultWithResultsEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RequestPermissionsResultWithResults += x, x => _data.RequestPermissionsResultWithResults -= x); + }, x => _data.RequestPermissionsResultWithResults += x, x => _data.RequestPermissionsResultWithResults -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1426,9 +1206,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Restart += x, x => _data.Restart -= x); + }, x => _data.Restart += x, x => _data.Restart -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1436,9 +1214,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.OS.Bundle e) => eventHandler(e); return Handler; - } - - , x => _data.RestoreInstanceState += x, x => _data.RestoreInstanceState -= x); + }, x => _data.RestoreInstanceState += x, x => _data.RestoreInstanceState -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1446,9 +1222,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.RestoreInstanceStateWithPersistedStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RestoreInstanceStateWithPersistedState += x, x => _data.RestoreInstanceStateWithPersistedState -= x); + }, x => _data.RestoreInstanceStateWithPersistedState += x, x => _data.RestoreInstanceStateWithPersistedState -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1456,9 +1230,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resume += x, x => _data.Resume -= x); + }, x => _data.Resume += x, x => _data.Resume -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1466,9 +1238,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ResumeFragments += x, x => _data.ResumeFragments -= x); + }, x => _data.ResumeFragments += x, x => _data.ResumeFragments -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1476,9 +1246,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RetainCustomNonConfigurationInstance += x, x => _data.RetainCustomNonConfigurationInstance -= x); + }, x => _data.RetainCustomNonConfigurationInstance += x, x => _data.RetainCustomNonConfigurationInstance -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1486,9 +1254,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.OS.Bundle e) => eventHandler(e); return Handler; - } - - , x => _data.SaveInstanceState += x, x => _data.SaveInstanceState -= x); + }, x => _data.SaveInstanceState += x, x => _data.SaveInstanceState -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1496,9 +1262,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.SaveInstanceStateWithPersistedStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SaveInstanceStateWithPersistedState += x, x => _data.SaveInstanceStateWithPersistedState -= x); + }, x => _data.SaveInstanceStateWithPersistedState += x, x => _data.SaveInstanceStateWithPersistedState -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1506,9 +1270,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchRequested += x, x => _data.SearchRequested -= x); + }, x => _data.SearchRequested += x, x => _data.SearchRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1516,9 +1278,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Start += x, x => _data.Start -= x); + }, x => _data.Start += x, x => _data.Start -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1526,9 +1286,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StateNotSaved += x, x => _data.StateNotSaved -= x); + }, x => _data.StateNotSaved += x, x => _data.StateNotSaved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1536,9 +1294,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Stop += x, x => _data.Stop -= x); + }, x => _data.Stop += x, x => _data.Stop -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1546,9 +1302,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.BaseActivity.TitleChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TitleChanged += x, x => _data.TitleChanged -= x); + }, x => _data.TitleChanged += x, x => _data.TitleChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1556,9 +1310,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.MotionEvent e) => eventHandler(e); return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); + }, x => _data.TouchEvent += x, x => _data.TouchEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1566,9 +1318,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.MotionEvent e) => eventHandler(e); return Handler; - } - - , x => _data.TrackballEvent += x, x => _data.TrackballEvent -= x); + }, x => _data.TrackballEvent += x, x => _data.TrackballEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1576,9 +1326,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Content.TrimMemory e) => eventHandler(e); return Handler; - } - - , x => _data.TrimMemory += x, x => _data.TrimMemory -= x); + }, x => _data.TrimMemory += x, x => _data.TrimMemory -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1586,9 +1334,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UserInteraction += x, x => _data.UserInteraction -= x); + }, x => _data.UserInteraction += x, x => _data.UserInteraction -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1596,9 +1342,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UserLeaveHint += x, x => _data.UserLeaveHint -= x); + }, x => _data.UserLeaveHint += x, x => _data.UserLeaveHint -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1606,9 +1350,7 @@ namespace Uno.UI { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VisibleBehindCanceled += x, x => _data.VisibleBehindCanceled -= x); + }, x => _data.VisibleBehindCanceled += x, x => _data.VisibleBehindCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1616,9 +1358,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.WindowManagerLayoutParams e) => eventHandler(e); return Handler; - } - - , x => _data.WindowAttributesChanged += x, x => _data.WindowAttributesChanged -= x); + }, x => _data.WindowAttributesChanged += x, x => _data.WindowAttributesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1626,9 +1366,7 @@ namespace Uno.UI { void Handler(object sender, bool e) => eventHandler(e); return Handler; - } - - , x => _data.WindowFocusChanged += x, x => _data.WindowFocusChanged -= x); + }, x => _data.WindowFocusChanged += x, x => _data.WindowFocusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1636,9 +1374,7 @@ namespace Uno.UI { void Handler(object sender, global::Android.Views.ActionMode.ICallback e) => eventHandler(e); return Handler; - } - - , x => _data.WindowStartingActionMode += x, x => _data.WindowStartingActionMode -= x); + }, x => _data.WindowStartingActionMode += x, x => _data.WindowStartingActionMode -= x); } /// @@ -1663,9 +1399,7 @@ namespace Uno.UI { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -1704,9 +1438,7 @@ namespace Uno.UI.Common { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } } @@ -1797,9 +1529,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1824,9 +1554,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1834,9 +1562,7 @@ namespace Uno.UI.Controls { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -1861,9 +1587,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1888,9 +1612,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1915,9 +1637,7 @@ namespace Uno.UI.Controls { void Handler(object sender, global::Uno.UI.Controls.ItemsSourceChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsSourceChanged += x, x => _data.ItemsSourceChanged -= x); + }, x => _data.ItemsSourceChanged += x, x => _data.ItemsSourceChanged -= x); } /// @@ -1942,9 +1662,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1969,9 +1687,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1996,9 +1712,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2006,9 +1720,7 @@ namespace Uno.UI.Controls { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -2033,9 +1745,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2043,9 +1753,7 @@ namespace Uno.UI.Controls { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -2070,9 +1778,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -2097,9 +1803,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -2124,9 +1828,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -2151,9 +1853,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2161,9 +1861,7 @@ namespace Uno.UI.Controls { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -2188,9 +1886,7 @@ namespace Uno.UI.Controls { void Handler(object sender, global::Uno.UI.Controls.ScreenChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScreenChanged += x, x => _data.ScreenChanged -= x); + }, x => _data.ScreenChanged += x, x => _data.ScreenChanged -= x); } } @@ -2241,9 +1937,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2251,9 +1945,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2261,9 +1953,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Controls.ItemClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemClick += x, x => _data.ItemClick -= x); + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2271,9 +1961,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2281,9 +1969,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2291,9 +1977,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2301,9 +1985,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2311,9 +1993,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2321,9 +2001,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2331,9 +2009,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -2358,9 +2034,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2368,9 +2042,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2378,9 +2050,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2388,9 +2058,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2398,9 +2066,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2408,9 +2074,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2418,9 +2082,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2428,9 +2090,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2438,9 +2098,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -2465,9 +2123,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2475,9 +2131,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2485,9 +2139,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2495,9 +2147,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2505,9 +2155,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2515,9 +2163,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2525,9 +2171,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2535,9 +2179,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2545,9 +2187,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2555,9 +2195,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -2582,9 +2220,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2592,9 +2228,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2602,9 +2236,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Controls.ItemClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemClick += x, x => _data.ItemClick -= x); + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2612,9 +2244,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2622,9 +2252,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2632,9 +2260,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2642,9 +2268,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2652,9 +2276,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2662,9 +2284,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2672,9 +2292,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2682,9 +2300,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } } @@ -2723,9 +2339,7 @@ namespace Uno.Xaml { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnNameScopeInitializationComplete += x, x => _data.OnNameScopeInitializationComplete -= x); + }, x => _data.OnNameScopeInitializationComplete += x, x => _data.OnNameScopeInitializationComplete -= x); } } @@ -2764,9 +2378,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageContentGroupStaging += x, x => _data.PackageContentGroupStaging -= x); + }, x => _data.PackageContentGroupStaging += x, x => _data.PackageContentGroupStaging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2774,9 +2386,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageInstalling += x, x => _data.PackageInstalling -= x); + }, x => _data.PackageInstalling += x, x => _data.PackageInstalling -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2784,9 +2394,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageStaging += x, x => _data.PackageStaging -= x); + }, x => _data.PackageStaging += x, x => _data.PackageStaging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2794,9 +2402,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2804,9 +2410,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2814,9 +2418,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); } } @@ -2855,9 +2457,7 @@ namespace Windows.ApplicationModel.Activation { void Handler(global::Windows.ApplicationModel.Activation.SplashScreen sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); } } @@ -2896,9 +2496,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageInstalled += x, x => _data.PackageInstalled -= x); + }, x => _data.PackageInstalled += x, x => _data.PackageInstalled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2906,9 +2504,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2916,9 +2512,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2926,9 +2520,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUpdated += x, x => _data.PackageUpdated -= x); + }, x => _data.PackageUpdated += x, x => _data.PackageUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2936,9 +2528,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); } } @@ -2981,9 +2571,7 @@ namespace Windows.ApplicationModel.Appointments { void Handler(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } /// @@ -3008,9 +2596,7 @@ namespace Windows.ApplicationModel.Appointments { void Handler(global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); } } @@ -3049,9 +2635,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CancelMeetingRequested += x, x => _data.CancelMeetingRequested -= x); + }, x => _data.CancelMeetingRequested += x, x => _data.CancelMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3059,9 +2643,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateOrUpdateAppointmentRequested += x, x => _data.CreateOrUpdateAppointmentRequested -= x); + }, x => _data.CreateOrUpdateAppointmentRequested += x, x => _data.CreateOrUpdateAppointmentRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3069,9 +2651,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3079,9 +2659,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3089,9 +2667,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3099,9 +2675,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); } } @@ -3140,9 +2714,7 @@ namespace Windows.ApplicationModel.AppService { void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3150,9 +2722,7 @@ namespace Windows.ApplicationModel.AppService { void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServiceClosed += x, x => _data.ServiceClosed -= x); + }, x => _data.ServiceClosed += x, x => _data.ServiceClosed -= x); } } @@ -3203,9 +2773,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3213,9 +2781,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Progress += x, x => _data.Progress -= x); + }, x => _data.Progress += x, x => _data.Progress -= x); } /// @@ -3240,9 +2806,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BackgroundActivated += x, x => _data.BackgroundActivated -= x); + }, x => _data.BackgroundActivated += x, x => _data.BackgroundActivated -= x); } /// @@ -3267,9 +2831,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); } /// @@ -3294,9 +2856,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3304,9 +2864,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Progress += x, x => _data.Progress -= x); + }, x => _data.Progress += x, x => _data.Progress -= x); } } @@ -3357,9 +2915,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteParticipantComposingChanged += x, x => _data.RemoteParticipantComposingChanged -= x); + }, x => _data.RemoteParticipantComposingChanged += x, x => _data.RemoteParticipantComposingChanged -= x); } /// @@ -3384,9 +2940,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageChanged += x, x => _data.MessageChanged -= x); + }, x => _data.MessageChanged += x, x => _data.MessageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3394,9 +2948,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); } /// @@ -3421,9 +2973,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageAvailableChanged += x, x => _data.MessageAvailableChanged -= x); + }, x => _data.MessageAvailableChanged += x, x => _data.MessageAvailableChanged -= x); } /// @@ -3448,9 +2998,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServiceKindSupportedChanged += x, x => _data.ServiceKindSupportedChanged -= x); + }, x => _data.ServiceKindSupportedChanged += x, x => _data.ServiceKindSupportedChanged -= x); } } @@ -3501,9 +3049,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); } /// @@ -3528,9 +3074,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } /// @@ -3555,9 +3099,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3565,9 +3107,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LaunchFullAppRequested += x, x => _data.LaunchFullAppRequested -= x); + }, x => _data.LaunchFullAppRequested += x, x => _data.LaunchFullAppRequested -= x); } /// @@ -3592,9 +3132,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); } } @@ -3633,9 +3171,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateOrUpdateContactRequested += x, x => _data.CreateOrUpdateContactRequested -= x); + }, x => _data.CreateOrUpdateContactRequested += x, x => _data.CreateOrUpdateContactRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3643,9 +3179,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeleteContactRequested += x, x => _data.DeleteContactRequested -= x); + }, x => _data.DeleteContactRequested += x, x => _data.DeleteContactRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3653,9 +3187,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3663,9 +3195,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); } } @@ -3704,9 +3234,7 @@ namespace Windows.ApplicationModel.Contacts.Provider { void Handler(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContactRemoved += x, x => _data.ContactRemoved -= x); + }, x => _data.ContactRemoved += x, x => _data.ContactRemoved -= x); } } @@ -3753,9 +3281,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3763,9 +3289,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HostedViewClosing += x, x => _data.HostedViewClosing -= x); + }, x => _data.HostedViewClosing += x, x => _data.HostedViewClosing -= x); } /// @@ -3790,9 +3314,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3800,9 +3322,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LayoutMetricsChanged += x, x => _data.LayoutMetricsChanged -= x); + }, x => _data.LayoutMetricsChanged += x, x => _data.LayoutMetricsChanged -= x); } /// @@ -3827,9 +3347,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UnhandledErrorDetected += x, x => _data.UnhandledErrorDetected -= x); + }, x => _data.UnhandledErrorDetected += x, x => _data.UnhandledErrorDetected -= x); } } @@ -3872,9 +3390,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3882,9 +3398,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3892,9 +3406,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShareCompleted += x, x => _data.ShareCompleted -= x); + }, x => _data.ShareCompleted += x, x => _data.ShareCompleted -= x); } /// @@ -3919,9 +3431,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataRequested += x, x => _data.DataRequested -= x); + }, x => _data.DataRequested += x, x => _data.DataRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3929,9 +3439,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShareProvidersRequested += x, x => _data.ShareProvidersRequested -= x); + }, x => _data.ShareProvidersRequested += x, x => _data.ShareProvidersRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3939,9 +3447,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetApplicationChosen += x, x => _data.TargetApplicationChosen -= x); + }, x => _data.TargetApplicationChosen += x, x => _data.TargetApplicationChosen -= x); } } @@ -3980,9 +3486,7 @@ namespace Windows.ApplicationModel.DataTransfer.DragDrop.Core { void Handler(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetRequested += x, x => _data.TargetRequested -= x); + }, x => _data.TargetRequested += x, x => _data.TargetRequested -= x); } } @@ -4025,9 +3529,7 @@ namespace Windows.ApplicationModel.Email { void Handler(global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MailboxChanged += x, x => _data.MailboxChanged -= x); + }, x => _data.MailboxChanged += x, x => _data.MailboxChanged -= x); } /// @@ -4052,9 +3554,7 @@ namespace Windows.ApplicationModel.Email { void Handler(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } } @@ -4093,9 +3593,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateFolderRequested += x, x => _data.CreateFolderRequested -= x); + }, x => _data.CreateFolderRequested += x, x => _data.CreateFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4103,9 +3601,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeleteFolderRequested += x, x => _data.DeleteFolderRequested -= x); + }, x => _data.DeleteFolderRequested += x, x => _data.DeleteFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4113,9 +3609,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadAttachmentRequested += x, x => _data.DownloadAttachmentRequested -= x); + }, x => _data.DownloadAttachmentRequested += x, x => _data.DownloadAttachmentRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4123,9 +3617,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadMessageRequested += x, x => _data.DownloadMessageRequested -= x); + }, x => _data.DownloadMessageRequested += x, x => _data.DownloadMessageRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4133,9 +3625,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EmptyFolderRequested += x, x => _data.EmptyFolderRequested -= x); + }, x => _data.EmptyFolderRequested += x, x => _data.EmptyFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4143,9 +3633,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4153,9 +3641,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GetAutoReplySettingsRequested += x, x => _data.GetAutoReplySettingsRequested -= x); + }, x => _data.GetAutoReplySettingsRequested += x, x => _data.GetAutoReplySettingsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4163,9 +3649,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MailboxSyncRequested += x, x => _data.MailboxSyncRequested -= x); + }, x => _data.MailboxSyncRequested += x, x => _data.MailboxSyncRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4173,9 +3657,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MoveFolderRequested += x, x => _data.MoveFolderRequested -= x); + }, x => _data.MoveFolderRequested += x, x => _data.MoveFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4183,9 +3665,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4193,9 +3673,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResolveRecipientsRequested += x, x => _data.ResolveRecipientsRequested -= x); + }, x => _data.ResolveRecipientsRequested += x, x => _data.ResolveRecipientsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4203,9 +3681,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4213,9 +3689,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetAutoReplySettingsRequested += x, x => _data.SetAutoReplySettingsRequested -= x); + }, x => _data.SetAutoReplySettingsRequested += x, x => _data.SetAutoReplySettingsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4223,9 +3697,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4233,9 +3705,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValidateCertificatesRequested += x, x => _data.ValidateCertificatesRequested -= x); + }, x => _data.ValidateCertificatesRequested += x, x => _data.ValidateCertificatesRequested -= x); } } @@ -4274,9 +3744,7 @@ namespace Windows.ApplicationModel.ExtendedExecution { void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionRevokedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Revoked += x, x => _data.Revoked -= x); + }, x => _data.Revoked += x, x => _data.Revoked -= x); } } @@ -4315,9 +3783,7 @@ namespace Windows.ApplicationModel.ExtendedExecution.Foreground { void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundRevokedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Revoked += x, x => _data.Revoked -= x); + }, x => _data.Revoked += x, x => _data.Revoked -= x); } } @@ -4360,9 +3826,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Unlocking += x, x => _data.Unlocking -= x); + }, x => _data.Unlocking += x, x => _data.Unlocking -= x); } /// @@ -4387,9 +3851,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AlarmIconChanged += x, x => _data.AlarmIconChanged -= x); + }, x => _data.AlarmIconChanged += x, x => _data.AlarmIconChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4397,9 +3859,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BadgesChanged += x, x => _data.BadgesChanged -= x); + }, x => _data.BadgesChanged += x, x => _data.BadgesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4407,9 +3867,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DetailTextChanged += x, x => _data.DetailTextChanged -= x); + }, x => _data.DetailTextChanged += x, x => _data.DetailTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4417,9 +3875,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LockScreenImageChanged += x, x => _data.LockScreenImageChanged -= x); + }, x => _data.LockScreenImageChanged += x, x => _data.LockScreenImageChanged -= x); } } @@ -4458,9 +3914,7 @@ namespace Windows.ApplicationModel.Resources.Core { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } } @@ -4499,9 +3953,7 @@ namespace Windows.ApplicationModel.Store { void Handler() => eventHandler(global::System.Reactive.Unit.Default); return Handler; - } - - , x => _data.LicenseChanged += x, x => _data.LicenseChanged -= x); + }, x => _data.LicenseChanged += x, x => _data.LicenseChanged -= x); } } @@ -4544,9 +3996,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4554,9 +4004,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -4581,9 +4029,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemCompleted += x, x => _data.ItemCompleted -= x); + }, x => _data.ItemCompleted += x, x => _data.ItemCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4591,9 +4037,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemStatusChanged += x, x => _data.ItemStatusChanged -= x); + }, x => _data.ItemStatusChanged += x, x => _data.ItemStatusChanged -= x); } } @@ -4632,9 +4076,7 @@ namespace Windows.ApplicationModel.UserActivities { void Handler(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserActivityRequested += x, x => _data.UserActivityRequested -= x); + }, x => _data.UserActivityRequested += x, x => _data.UserActivityRequested -= x); } } @@ -4673,9 +4115,7 @@ namespace Windows.ApplicationModel.UserDataAccounts { void Handler(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); } } @@ -4714,9 +4154,7 @@ namespace Windows.ApplicationModel.UserDataTasks { void Handler(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } } @@ -4755,9 +4193,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompleteTaskRequested += x, x => _data.CompleteTaskRequested -= x); + }, x => _data.CompleteTaskRequested += x, x => _data.CompleteTaskRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4765,9 +4201,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateOrUpdateTaskRequested += x, x => _data.CreateOrUpdateTaskRequested -= x); + }, x => _data.CreateOrUpdateTaskRequested += x, x => _data.CreateOrUpdateTaskRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4775,9 +4209,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeleteTaskRequested += x, x => _data.DeleteTaskRequested -= x); + }, x => _data.DeleteTaskRequested += x, x => _data.DeleteTaskRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4785,9 +4217,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SkipOccurrenceRequested += x, x => _data.SkipOccurrenceRequested -= x); + }, x => _data.SkipOccurrenceRequested += x, x => _data.SkipOccurrenceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4795,9 +4225,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); } } @@ -4836,9 +4264,7 @@ namespace Windows.ApplicationModel.VoiceCommands { void Handler(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VoiceCommandCompleted += x, x => _data.VoiceCommandCompleted -= x); + }, x => _data.VoiceCommandCompleted += x, x => _data.VoiceCommandCompleted -= x); } } @@ -4877,9 +4303,7 @@ namespace Windows.ApplicationModel.Wallet.System { void Handler(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); } } @@ -4926,9 +4350,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceptSessionJoinerRequested += x, x => _data.AcceptSessionJoinerRequested -= x); + }, x => _data.AcceptSessionJoinerRequested += x, x => _data.AcceptSessionJoinerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4936,9 +4358,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AuthenticationComplete += x, x => _data.AuthenticationComplete -= x); + }, x => _data.AuthenticationComplete += x, x => _data.AuthenticationComplete -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4946,9 +4366,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CredentialsRequested += x, x => _data.CredentialsRequested -= x); + }, x => _data.CredentialsRequested += x, x => _data.CredentialsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4956,9 +4374,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CredentialsVerificationRequested += x, x => _data.CredentialsVerificationRequested -= x); + }, x => _data.CredentialsVerificationRequested += x, x => _data.CredentialsVerificationRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4966,9 +4382,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionJoined += x, x => _data.SessionJoined -= x); + }, x => _data.SessionJoined += x, x => _data.SessionJoined -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4976,9 +4390,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -5003,9 +4415,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -5030,9 +4440,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Lost += x, x => _data.Lost -= x); + }, x => _data.Lost += x, x => _data.Lost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5040,9 +4448,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MemberAdded += x, x => _data.MemberAdded -= x); + }, x => _data.MemberAdded += x, x => _data.MemberAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5050,9 +4456,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MemberRemoved += x, x => _data.MemberRemoved -= x); + }, x => _data.MemberRemoved += x, x => _data.MemberRemoved -= x); } } @@ -5095,9 +4499,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5105,9 +4507,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NameChanged += x, x => _data.NameChanged -= x); + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5115,9 +4515,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SdpRecordsChanged += x, x => _data.SdpRecordsChanged -= x); + }, x => _data.SdpRecordsChanged += x, x => _data.SdpRecordsChanged -= x); } /// @@ -5142,9 +4540,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5152,9 +4548,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GattServicesChanged += x, x => _data.GattServicesChanged -= x); + }, x => _data.GattServicesChanged += x, x => _data.GattServicesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5162,9 +4556,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NameChanged += x, x => _data.NameChanged -= x); + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); } } @@ -5207,9 +4599,7 @@ namespace Windows.Devices.Bluetooth.Advertisement { void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -5234,9 +4624,7 @@ namespace Windows.Devices.Bluetooth.Advertisement { void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Received += x, x => _data.Received -= x); + }, x => _data.Received += x, x => _data.Received -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5244,9 +4632,7 @@ namespace Windows.Devices.Bluetooth.Advertisement { void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -5313,9 +4699,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -5340,9 +4724,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5350,9 +4732,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SubscribedClientsChanged += x, x => _data.SubscribedClientsChanged -= x); + }, x => _data.SubscribedClientsChanged += x, x => _data.SubscribedClientsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5360,9 +4740,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); } /// @@ -5387,9 +4765,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5397,9 +4773,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); } /// @@ -5424,9 +4798,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -5451,9 +4823,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); } /// @@ -5478,9 +4848,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MaxPduSizeChanged += x, x => _data.MaxPduSizeChanged -= x); + }, x => _data.MaxPduSizeChanged += x, x => _data.MaxPduSizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5488,9 +4856,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); } /// @@ -5515,9 +4881,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MaxNotificationSizeChanged += x, x => _data.MaxNotificationSizeChanged -= x); + }, x => _data.MaxNotificationSizeChanged += x, x => _data.MaxNotificationSizeChanged -= x); } /// @@ -5542,9 +4906,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -5583,9 +4945,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5593,9 +4953,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Disabled += x, x => _data.Disabled -= x); + }, x => _data.Disabled += x, x => _data.Disabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5603,9 +4961,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Enabled += x, x => _data.Enabled -= x); + }, x => _data.Enabled += x, x => _data.Enabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5613,9 +4969,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PathsFailedOrInvalidated += x, x => _data.PathsFailedOrInvalidated -= x); + }, x => _data.PathsFailedOrInvalidated += x, x => _data.PathsFailedOrInvalidated -= x); } } @@ -5666,9 +5020,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessChanged += x, x => _data.AccessChanged -= x); + }, x => _data.AccessChanged += x, x => _data.AccessChanged -= x); } /// @@ -5693,9 +5045,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PairingRequested += x, x => _data.PairingRequested -= x); + }, x => _data.PairingRequested += x, x => _data.PairingRequested -= x); } /// @@ -5720,9 +5070,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DevicePickerDismissed += x, x => _data.DevicePickerDismissed -= x); + }, x => _data.DevicePickerDismissed += x, x => _data.DevicePickerDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5730,9 +5078,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeviceSelected += x, x => _data.DeviceSelected -= x); + }, x => _data.DeviceSelected += x, x => _data.DeviceSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5740,9 +5086,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); } /// @@ -5767,9 +5111,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5777,9 +5119,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5787,9 +5127,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5797,9 +5135,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5807,9 +5143,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -5848,9 +5182,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5858,9 +5190,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5868,9 +5198,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5878,9 +5206,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5888,9 +5214,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -5933,9 +5257,7 @@ namespace Windows.Devices.Geolocation { void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5943,9 +5265,7 @@ namespace Windows.Devices.Geolocation { void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -5970,9 +5290,7 @@ namespace Windows.Devices.Geolocation { void Handler(global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisitStateChanged += x, x => _data.VisitStateChanged -= x); + }, x => _data.VisitStateChanged += x, x => _data.VisitStateChanged -= x); } } @@ -6011,9 +5329,7 @@ namespace Windows.Devices.Geolocation.Geofencing { void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GeofenceStateChanged += x, x => _data.GeofenceStateChanged -= x); + }, x => _data.GeofenceStateChanged += x, x => _data.GeofenceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6021,9 +5337,7 @@ namespace Windows.Devices.Geolocation.Geofencing { void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } } @@ -6062,9 +5376,7 @@ namespace Windows.Devices.HumanInterfaceDevice { void Handler(global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputReportReceived += x, x => _data.InputReportReceived -= x); + }, x => _data.InputReportReceived += x, x => _data.InputReportReceived -= x); } } @@ -6103,9 +5415,7 @@ namespace Windows.Devices.Input { void Handler(global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MouseMoved += x, x => _data.MouseMoved -= x); + }, x => _data.MouseMoved += x, x => _data.MouseMoved -= x); } } @@ -6148,9 +5458,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6158,9 +5466,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6168,9 +5474,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6178,9 +5482,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -6205,9 +5507,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GazeEntered += x, x => _data.GazeEntered -= x); + }, x => _data.GazeEntered += x, x => _data.GazeEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6215,9 +5515,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GazeExited += x, x => _data.GazeExited -= x); + }, x => _data.GazeExited += x, x => _data.GazeExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6225,9 +5523,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GazeMoved += x, x => _data.GazeMoved -= x); + }, x => _data.GazeMoved += x, x => _data.GazeMoved -= x); } } @@ -6266,9 +5562,7 @@ namespace Windows.Devices.Lights { void Handler(global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); + }, x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); } } @@ -6311,9 +5605,7 @@ namespace Windows.Devices.Lights.Effects { void Handler(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); } /// @@ -6338,9 +5630,7 @@ namespace Windows.Devices.Lights.Effects { void Handler(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateRequested += x, x => _data.UpdateRequested -= x); + }, x => _data.UpdateRequested += x, x => _data.UpdateRequested -= x); } } @@ -6379,9 +5669,7 @@ namespace Windows.Devices.Midi { void Handler(global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } } @@ -6456,9 +5744,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -6483,9 +5769,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6493,9 +5777,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6503,9 +5785,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6513,9 +5793,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6523,9 +5801,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); } /// @@ -6550,9 +5826,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6560,9 +5834,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6570,9 +5842,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6580,9 +5850,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -6607,9 +5875,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionControlSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ControlLost += x, x => _data.ControlLost -= x); + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); } /// @@ -6634,9 +5900,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -6661,9 +5925,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6671,9 +5933,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6681,9 +5941,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6691,9 +5949,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6701,9 +5957,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); } /// @@ -6728,9 +5982,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6738,9 +5990,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6748,9 +5998,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6758,9 +6006,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -6785,9 +6031,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -6812,9 +6056,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6822,9 +6064,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6832,9 +6072,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6842,9 +6080,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6852,9 +6088,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); } /// @@ -6879,9 +6113,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6889,9 +6121,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6899,9 +6129,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6909,9 +6137,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -6990,9 +6216,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -7017,9 +6241,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -7044,9 +6266,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AlarmTimeoutExpired += x, x => _data.AlarmTimeoutExpired -= x); + }, x => _data.AlarmTimeoutExpired += x, x => _data.AlarmTimeoutExpired -= x); } /// @@ -7071,9 +6291,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); + }, x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7081,9 +6299,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); + }, x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); } /// @@ -7108,9 +6324,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7118,9 +6332,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7128,9 +6340,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7138,9 +6348,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ImagePreviewReceived += x, x => _data.ImagePreviewReceived -= x); + }, x => _data.ImagePreviewReceived += x, x => _data.ImagePreviewReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7148,9 +6356,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7158,9 +6364,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); return Handler; - } - - , x => _data.TriggerPressed += x, x => _data.TriggerPressed -= x); + }, x => _data.TriggerPressed += x, x => _data.TriggerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7168,9 +6372,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); return Handler; - } - - , x => _data.TriggerReleased += x, x => _data.TriggerReleased -= x); + }, x => _data.TriggerReleased += x, x => _data.TriggerReleased -= x); } /// @@ -7195,9 +6397,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7205,9 +6405,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); } /// @@ -7232,9 +6430,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7242,9 +6438,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7252,9 +6446,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -7279,9 +6471,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AamvaCardDataReceived += x, x => _data.AamvaCardDataReceived -= x); + }, x => _data.AamvaCardDataReceived += x, x => _data.AamvaCardDataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7289,9 +6479,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BankCardDataReceived += x, x => _data.BankCardDataReceived -= x); + }, x => _data.BankCardDataReceived += x, x => _data.BankCardDataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7299,9 +6487,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7309,9 +6495,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7319,9 +6503,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader e) => eventHandler(e); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7329,9 +6511,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VendorSpecificDataReceived += x, x => _data.VendorSpecificDataReceived -= x); + }, x => _data.VendorSpecificDataReceived += x, x => _data.VendorSpecificDataReceived -= x); } /// @@ -7356,9 +6536,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7366,9 +6544,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); } /// @@ -7393,9 +6569,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -7420,9 +6594,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } } @@ -7465,9 +6637,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -7492,9 +6662,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisableScannerRequested += x, x => _data.DisableScannerRequested -= x); + }, x => _data.DisableScannerRequested += x, x => _data.DisableScannerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7502,9 +6670,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnableScannerRequested += x, x => _data.EnableScannerRequested -= x); + }, x => _data.EnableScannerRequested += x, x => _data.EnableScannerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7512,9 +6678,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GetBarcodeSymbologyAttributesRequested += x, x => _data.GetBarcodeSymbologyAttributesRequested -= x); + }, x => _data.GetBarcodeSymbologyAttributesRequested += x, x => _data.GetBarcodeSymbologyAttributesRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7522,9 +6686,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HideVideoPreviewRequested += x, x => _data.HideVideoPreviewRequested -= x); + }, x => _data.HideVideoPreviewRequested += x, x => _data.HideVideoPreviewRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7532,9 +6694,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetActiveSymbologiesRequested += x, x => _data.SetActiveSymbologiesRequested -= x); + }, x => _data.SetActiveSymbologiesRequested += x, x => _data.SetActiveSymbologiesRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7542,9 +6702,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetBarcodeSymbologyAttributesRequested += x, x => _data.SetBarcodeSymbologyAttributesRequested -= x); + }, x => _data.SetBarcodeSymbologyAttributesRequested += x, x => _data.SetBarcodeSymbologyAttributesRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7552,9 +6710,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StartSoftwareTriggerRequested += x, x => _data.StartSoftwareTriggerRequested -= x); + }, x => _data.StartSoftwareTriggerRequested += x, x => _data.StartSoftwareTriggerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7562,9 +6718,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StopSoftwareTriggerRequested += x, x => _data.StopSoftwareTriggerRequested -= x); + }, x => _data.StopSoftwareTriggerRequested += x, x => _data.StopSoftwareTriggerRequested -= x); } } @@ -7603,9 +6757,7 @@ namespace Windows.Devices.Power { void Handler(global::Windows.Devices.Power.Battery sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReportUpdated += x, x => _data.ReportUpdated -= x); + }, x => _data.ReportUpdated += x, x => _data.ReportUpdated -= x); } } @@ -7644,9 +6796,7 @@ namespace Windows.Devices.Printers.Extensions { void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrinterChanged += x, x => _data.PrinterChanged -= x); + }, x => _data.PrinterChanged += x, x => _data.PrinterChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7654,9 +6804,7 @@ namespace Windows.Devices.Printers.Extensions { void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrintRequested += x, x => _data.PrintRequested -= x); + }, x => _data.PrintRequested += x, x => _data.PrintRequested -= x); } } @@ -7695,9 +6843,7 @@ namespace Windows.Devices.Radios { void Handler(global::Windows.Devices.Radios.Radio sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -7788,9 +6934,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7798,9 +6942,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Shaken += x, x => _data.Shaken -= x); + }, x => _data.Shaken += x, x => _data.Shaken -= x); } /// @@ -7825,9 +6967,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -7852,9 +6992,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -7879,9 +7017,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -7906,9 +7042,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -7933,9 +7067,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -7960,9 +7092,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -7987,9 +7117,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -8014,9 +7142,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -8041,9 +7167,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -8068,9 +7192,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -8095,9 +7217,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -8122,9 +7242,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -8149,9 +7267,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); } } @@ -8190,9 +7306,7 @@ namespace Windows.Devices.Sensors.Custom { void Handler(global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } } @@ -8231,9 +7345,7 @@ namespace Windows.Devices.SerialCommunication { void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorReceived += x, x => _data.ErrorReceived -= x); + }, x => _data.ErrorReceived += x, x => _data.ErrorReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8241,9 +7353,7 @@ namespace Windows.Devices.SerialCommunication { void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PinChanged += x, x => _data.PinChanged -= x); + }, x => _data.PinChanged += x, x => _data.PinChanged -= x); } } @@ -8282,9 +7392,7 @@ namespace Windows.Devices.SmartCards { void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CardAdded += x, x => _data.CardAdded -= x); + }, x => _data.CardAdded += x, x => _data.CardAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8292,9 +7400,7 @@ namespace Windows.Devices.SmartCards { void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CardRemoved += x, x => _data.CardRemoved -= x); + }, x => _data.CardRemoved += x, x => _data.CardRemoved -= x); } } @@ -8337,9 +7443,7 @@ namespace Windows.Devices.Sms { void Handler(global::Windows.Devices.Sms.SmsDevice2 sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeviceStatusChanged += x, x => _data.DeviceStatusChanged -= x); + }, x => _data.DeviceStatusChanged += x, x => _data.DeviceStatusChanged -= x); } /// @@ -8364,9 +7468,7 @@ namespace Windows.Devices.Sms { void Handler(global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } } @@ -8405,9 +7507,7 @@ namespace Windows.Devices.Usb { void Handler(global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); } } @@ -8446,9 +7546,7 @@ namespace Windows.Devices.WiFi { void Handler(global::Windows.Devices.WiFi.WiFiAdapter sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableNetworksChanged += x, x => _data.AvailableNetworksChanged -= x); + }, x => _data.AvailableNetworksChanged += x, x => _data.AvailableNetworksChanged -= x); } } @@ -8495,9 +7593,7 @@ namespace Windows.Devices.WiFiDirect { void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -8522,9 +7618,7 @@ namespace Windows.Devices.WiFiDirect { void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); + }, x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); } /// @@ -8549,9 +7643,7 @@ namespace Windows.Devices.WiFiDirect { void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); } } @@ -8598,9 +7690,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionDeferred += x, x => _data.SessionDeferred -= x); + }, x => _data.SessionDeferred += x, x => _data.SessionDeferred -= x); } /// @@ -8625,9 +7715,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8635,9 +7723,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutoAcceptSessionConnected += x, x => _data.AutoAcceptSessionConnected -= x); + }, x => _data.AutoAcceptSessionConnected += x, x => _data.AutoAcceptSessionConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8645,9 +7731,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionRequested += x, x => _data.SessionRequested -= x); + }, x => _data.SessionRequested += x, x => _data.SessionRequested -= x); } /// @@ -8672,9 +7756,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemotePortAdded += x, x => _data.RemotePortAdded -= x); + }, x => _data.RemotePortAdded += x, x => _data.RemotePortAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8682,9 +7764,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); } } @@ -8723,9 +7803,7 @@ namespace Windows.Foundation { void Handler(global::Windows.Foundation.IMemoryBufferReference sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } } @@ -8772,9 +7850,7 @@ namespace Windows.Foundation.Collections { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -8799,9 +7875,7 @@ namespace Windows.Foundation.Collections { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -8826,9 +7900,7 @@ namespace Windows.Foundation.Collections { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } } @@ -8879,9 +7951,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); } /// @@ -8906,9 +7976,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); } /// @@ -8933,9 +8001,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); } /// @@ -8960,9 +8026,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); } } @@ -9025,9 +8089,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9035,9 +8097,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9045,9 +8105,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -9072,9 +8130,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9082,9 +8138,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9092,9 +8146,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -9119,9 +8171,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9129,9 +8179,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9139,9 +8187,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -9166,9 +8212,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9176,9 +8220,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9186,9 +8228,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -9213,9 +8253,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9223,9 +8261,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9233,9 +8269,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -9260,9 +8294,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9270,9 +8302,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9280,9 +8310,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -9307,9 +8335,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9317,9 +8343,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9327,9 +8351,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } } @@ -9372,9 +8394,7 @@ namespace Windows.Graphics.Capture { void Handler(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -9399,9 +8419,7 @@ namespace Windows.Graphics.Capture { void Handler(global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } } @@ -9448,9 +8466,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BrightnessLevelChanged += x, x => _data.BrightnessLevelChanged -= x); + }, x => _data.BrightnessLevelChanged += x, x => _data.BrightnessLevelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9458,9 +8474,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9468,9 +8482,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); + }, x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); } /// @@ -9495,9 +8507,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CanOverrideChanged += x, x => _data.CanOverrideChanged -= x); + }, x => _data.CanOverrideChanged += x, x => _data.CanOverrideChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9505,9 +8515,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisplayEnhancementOverrideCapabilitiesChanged += x, x => _data.DisplayEnhancementOverrideCapabilitiesChanged -= x); + }, x => _data.DisplayEnhancementOverrideCapabilitiesChanged += x, x => _data.DisplayEnhancementOverrideCapabilitiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9515,9 +8523,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); } /// @@ -9542,9 +8548,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvancedColorInfoChanged += x, x => _data.AdvancedColorInfoChanged -= x); + }, x => _data.AdvancedColorInfoChanged += x, x => _data.AdvancedColorInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9552,9 +8556,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorProfileChanged += x, x => _data.ColorProfileChanged -= x); + }, x => _data.ColorProfileChanged += x, x => _data.ColorProfileChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9562,9 +8564,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9572,9 +8572,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9582,9 +8580,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StereoEnabledChanged += x, x => _data.StereoEnabledChanged -= x); + }, x => _data.StereoEnabledChanged += x, x => _data.StereoEnabledChanged -= x); } } @@ -9623,9 +8619,7 @@ namespace Windows.Graphics.Display.Core { void Handler(global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisplayModesChanged += x, x => _data.DisplayModesChanged -= x); + }, x => _data.DisplayModesChanged += x, x => _data.DisplayModesChanged -= x); } } @@ -9664,9 +8658,7 @@ namespace Windows.Graphics.Holographic { void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraAdded += x, x => _data.CameraAdded -= x); + }, x => _data.CameraAdded += x, x => _data.CameraAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9674,9 +8666,7 @@ namespace Windows.Graphics.Holographic { void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraRemoved += x, x => _data.CameraRemoved -= x); + }, x => _data.CameraRemoved += x, x => _data.CameraRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9684,9 +8674,7 @@ namespace Windows.Graphics.Holographic { void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserPresenceChanged += x, x => _data.UserPresenceChanged -= x); + }, x => _data.UserPresenceChanged += x, x => _data.UserPresenceChanged -= x); } } @@ -9729,9 +8717,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrintTaskRequested += x, x => _data.PrintTaskRequested -= x); + }, x => _data.PrintTaskRequested += x, x => _data.PrintTaskRequested -= x); } /// @@ -9756,9 +8742,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9766,9 +8750,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Previewing += x, x => _data.Previewing -= x); + }, x => _data.Previewing += x, x => _data.Previewing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9776,9 +8758,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Progressing += x, x => _data.Progressing -= x); + }, x => _data.Progressing += x, x => _data.Progressing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9786,9 +8766,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Submitting += x, x => _data.Submitting -= x); + }, x => _data.Submitting += x, x => _data.Submitting -= x); } } @@ -9827,9 +8805,7 @@ namespace Windows.Graphics.Printing.OptionDetails { void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BeginValidation += x, x => _data.BeginValidation -= x); + }, x => _data.BeginValidation += x, x => _data.BeginValidation -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9837,9 +8813,7 @@ namespace Windows.Graphics.Printing.OptionDetails { void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionChanged += x, x => _data.OptionChanged -= x); + }, x => _data.OptionChanged += x, x => _data.OptionChanged -= x); } } @@ -9882,9 +8856,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9892,9 +8864,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Submitted += x, x => _data.Submitted -= x); + }, x => _data.Submitted += x, x => _data.Submitted -= x); } /// @@ -9919,9 +8889,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9929,9 +8897,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.XpsDataAvailable += x, x => _data.XpsDataAvailable -= x); + }, x => _data.XpsDataAvailable += x, x => _data.XpsDataAvailable -= x); } } @@ -9970,9 +8936,7 @@ namespace Windows.Management.Policies { void Handler(global::Windows.Management.Policies.NamedPolicyData sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } } @@ -10015,9 +8979,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Ended += x, x => _data.Ended -= x); + }, x => _data.Ended += x, x => _data.Ended -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10025,9 +8987,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Failed += x, x => _data.Failed -= x); + }, x => _data.Failed += x, x => _data.Failed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10035,9 +8995,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10045,9 +9003,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -10072,9 +9028,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutoRepeatModeChangeRequested += x, x => _data.AutoRepeatModeChangeRequested -= x); + }, x => _data.AutoRepeatModeChangeRequested += x, x => _data.AutoRepeatModeChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10082,9 +9036,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10092,9 +9044,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackPositionChangeRequested += x, x => _data.PlaybackPositionChangeRequested -= x); + }, x => _data.PlaybackPositionChangeRequested += x, x => _data.PlaybackPositionChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10102,9 +9052,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10112,9 +9060,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10122,9 +9068,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShuffleEnabledChangeRequested += x, x => _data.ShuffleEnabledChangeRequested -= x); + }, x => _data.ShuffleEnabledChangeRequested += x, x => _data.ShuffleEnabledChangeRequested -= x); } } @@ -10183,9 +9127,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioFileInputNode sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileCompleted += x, x => _data.FileCompleted -= x); + }, x => _data.FileCompleted += x, x => _data.FileCompleted -= x); } /// @@ -10210,9 +9152,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioFrameCompleted += x, x => _data.AudioFrameCompleted -= x); + }, x => _data.AudioFrameCompleted += x, x => _data.AudioFrameCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10220,9 +9160,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); } /// @@ -10247,9 +9185,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuantumProcessed += x, x => _data.QuantumProcessed -= x); + }, x => _data.QuantumProcessed += x, x => _data.QuantumProcessed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10257,9 +9193,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10267,9 +9201,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnrecoverableErrorOccurred += x, x => _data.UnrecoverableErrorOccurred -= x); + }, x => _data.UnrecoverableErrorOccurred += x, x => _data.UnrecoverableErrorOccurred -= x); } /// @@ -10294,9 +9226,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioStateMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SoundLevelChanged += x, x => _data.SoundLevelChanged -= x); + }, x => _data.SoundLevelChanged += x, x => _data.SoundLevelChanged -= x); } /// @@ -10321,9 +9251,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaSourceCompleted += x, x => _data.MediaSourceCompleted -= x); + }, x => _data.MediaSourceCompleted += x, x => _data.MediaSourceCompleted -= x); } /// @@ -10348,9 +9276,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } } @@ -10405,9 +9331,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AllPhotosCaptured += x, x => _data.AllPhotosCaptured -= x); + }, x => _data.AllPhotosCaptured += x, x => _data.AllPhotosCaptured -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10415,9 +9339,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionalReferencePhotoCaptured += x, x => _data.OptionalReferencePhotoCaptured -= x); + }, x => _data.OptionalReferencePhotoCaptured += x, x => _data.OptionalReferencePhotoCaptured -= x); } /// @@ -10442,9 +9364,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.AppCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CapturingChanged += x, x => _data.CapturingChanged -= x); + }, x => _data.CapturingChanged += x, x => _data.CapturingChanged -= x); } /// @@ -10469,9 +9389,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); } /// @@ -10496,9 +9414,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraStreamStateChanged += x, x => _data.CameraStreamStateChanged -= x); + }, x => _data.CameraStreamStateChanged += x, x => _data.CameraStreamStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10506,9 +9422,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CaptureDeviceExclusiveControlStatusChanged += x, x => _data.CaptureDeviceExclusiveControlStatusChanged -= x); + }, x => _data.CaptureDeviceExclusiveControlStatusChanged += x, x => _data.CaptureDeviceExclusiveControlStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10516,9 +9430,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFailedEventArgs errorEventArgs) => eventHandler((sender, errorEventArgs)); return Handler; - } - - , x => _data.Failed += x, x => _data.Failed -= x); + }, x => _data.Failed += x, x => _data.Failed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10526,9 +9438,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusChanged += x, x => _data.FocusChanged -= x); + }, x => _data.FocusChanged += x, x => _data.FocusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10536,9 +9446,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PhotoConfirmationCaptured += x, x => _data.PhotoConfirmationCaptured -= x); + }, x => _data.PhotoConfirmationCaptured += x, x => _data.PhotoConfirmationCaptured -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10546,9 +9454,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender) => eventHandler(sender); return Handler; - } - - , x => _data.RecordLimitationExceeded += x, x => _data.RecordLimitationExceeded -= x); + }, x => _data.RecordLimitationExceeded += x, x => _data.RecordLimitationExceeded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10556,9 +9462,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThermalStatusChanged += x, x => _data.ThermalStatusChanged -= x); + }, x => _data.ThermalStatusChanged += x, x => _data.ThermalStatusChanged -= x); } /// @@ -10583,9 +9487,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceSuspensionChanged += x, x => _data.SourceSuspensionChanged -= x); + }, x => _data.SourceSuspensionChanged += x, x => _data.SourceSuspensionChanged -= x); } } @@ -10624,9 +9526,7 @@ namespace Windows.Media.Capture.Core { void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10634,9 +9534,7 @@ namespace Windows.Media.Capture.Core { void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -10683,9 +9581,7 @@ namespace Windows.Media.Capture.Frames { void Handler(global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -10710,9 +9606,7 @@ namespace Windows.Media.Capture.Frames { void Handler(global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); } /// @@ -10737,9 +9631,7 @@ namespace Windows.Media.Capture.Frames { void Handler(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } } @@ -10782,9 +9674,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10792,9 +9682,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingConnection sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -10819,9 +9707,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CastingDevicePickerDismissed += x, x => _data.CastingDevicePickerDismissed -= x); + }, x => _data.CastingDevicePickerDismissed += x, x => _data.CastingDevicePickerDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10829,9 +9715,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CastingDeviceSelected += x, x => _data.CastingDeviceSelected -= x); + }, x => _data.CastingDeviceSelected += x, x => _data.CastingDeviceSelected -= x); } } @@ -10870,9 +9754,7 @@ namespace Windows.Media.ContentRestrictions { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.RestrictionsChanged += x, x => _data.RestrictionsChanged -= x); + }, x => _data.RestrictionsChanged += x, x => _data.RestrictionsChanged -= x); } } @@ -10915,9 +9797,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaPropertiesChanged += x, x => _data.MediaPropertiesChanged -= x); + }, x => _data.MediaPropertiesChanged += x, x => _data.MediaPropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10925,9 +9805,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackInfoChanged += x, x => _data.PlaybackInfoChanged -= x); + }, x => _data.PlaybackInfoChanged += x, x => _data.PlaybackInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10935,9 +9813,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimelinePropertiesChanged += x, x => _data.TimelinePropertiesChanged -= x); + }, x => _data.TimelinePropertiesChanged += x, x => _data.TimelinePropertiesChanged -= x); } /// @@ -10962,9 +9838,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentSessionChanged += x, x => _data.CurrentSessionChanged -= x); + }, x => _data.CurrentSessionChanged += x, x => _data.CurrentSessionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10972,9 +9846,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionsChanged += x, x => _data.SessionsChanged -= x); + }, x => _data.SessionsChanged += x, x => _data.SessionsChanged -= x); } } @@ -11077,9 +9949,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); } /// @@ -11104,9 +9974,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FaceDetected += x, x => _data.FaceDetected -= x); + }, x => _data.FaceDetected += x, x => _data.FaceDetected -= x); } /// @@ -11131,9 +9999,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -11158,9 +10024,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Binding += x, x => _data.Binding -= x); + }, x => _data.Binding += x, x => _data.Binding -= x); } /// @@ -11185,9 +10049,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaBindingEventArgs sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); } /// @@ -11212,9 +10074,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenOperationCompleted += x, x => _data.OpenOperationCompleted -= x); + }, x => _data.OpenOperationCompleted += x, x => _data.OpenOperationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11222,9 +10082,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -11249,9 +10107,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InitializeMediaStreamSourceRequested += x, x => _data.InitializeMediaStreamSourceRequested -= x); + }, x => _data.InitializeMediaStreamSourceRequested += x, x => _data.InitializeMediaStreamSourceRequested -= x); } /// @@ -11276,9 +10132,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSample sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Processed += x, x => _data.Processed -= x); + }, x => _data.Processed += x, x => _data.Processed -= x); } /// @@ -11303,9 +10157,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11313,9 +10165,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Paused += x, x => _data.Paused -= x); + }, x => _data.Paused += x, x => _data.Paused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11323,9 +10173,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SampleRendered += x, x => _data.SampleRendered -= x); + }, x => _data.SampleRendered += x, x => _data.SampleRendered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11333,9 +10181,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SampleRequested += x, x => _data.SampleRequested -= x); + }, x => _data.SampleRequested += x, x => _data.SampleRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11343,9 +10189,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Starting += x, x => _data.Starting -= x); + }, x => _data.Starting += x, x => _data.Starting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11353,9 +10197,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SwitchStreamsRequested += x, x => _data.SwitchStreamsRequested -= x); + }, x => _data.SwitchStreamsRequested += x, x => _data.SwitchStreamsRequested -= x); } /// @@ -11380,9 +10222,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Aborted += x, x => _data.Aborted -= x); + }, x => _data.Aborted += x, x => _data.Aborted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11390,9 +10230,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11400,9 +10238,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11410,9 +10246,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateEnded += x, x => _data.UpdateEnded -= x); + }, x => _data.UpdateEnded += x, x => _data.UpdateEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11420,9 +10254,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateStarting += x, x => _data.UpdateStarting -= x); + }, x => _data.UpdateStarting += x, x => _data.UpdateStarting -= x); } /// @@ -11447,9 +10279,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceBufferAdded += x, x => _data.SourceBufferAdded -= x); + }, x => _data.SourceBufferAdded += x, x => _data.SourceBufferAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11457,9 +10287,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceBufferRemoved += x, x => _data.SourceBufferRemoved -= x); + }, x => _data.SourceBufferRemoved += x, x => _data.SourceBufferRemoved -= x); } /// @@ -11484,9 +10312,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11494,9 +10320,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Ended += x, x => _data.Ended -= x); + }, x => _data.Ended += x, x => _data.Ended -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11504,9 +10328,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -11531,9 +10353,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SceneAnalyzed += x, x => _data.SceneAnalyzed -= x); + }, x => _data.SceneAnalyzed += x, x => _data.SceneAnalyzed -= x); } /// @@ -11558,9 +10378,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CueEntered += x, x => _data.CueEntered -= x); + }, x => _data.CueEntered += x, x => _data.CueEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11568,9 +10386,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CueExited += x, x => _data.CueExited -= x); + }, x => _data.CueExited += x, x => _data.CueExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11578,9 +10394,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TrackFailed += x, x => _data.TrackFailed -= x); + }, x => _data.TrackFailed += x, x => _data.TrackFailed -= x); } /// @@ -11605,9 +10419,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Resolved += x, x => _data.Resolved -= x); + }, x => _data.Resolved += x, x => _data.Resolved -= x); } /// @@ -11632,9 +10444,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); } /// @@ -11659,9 +10469,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); } } @@ -11700,9 +10508,7 @@ namespace Windows.Media.Devices { void Handler(global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ModuleNotificationReceived += x, x => _data.ModuleNotificationReceived -= x); + }, x => _data.ModuleNotificationReceived += x, x => _data.ModuleNotificationReceived -= x); } } @@ -11741,9 +10547,7 @@ namespace Windows.Media.DialProtocol { void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DialDevicePickerDismissed += x, x => _data.DialDevicePickerDismissed -= x); + }, x => _data.DialDevicePickerDismissed += x, x => _data.DialDevicePickerDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11751,9 +10555,7 @@ namespace Windows.Media.DialProtocol { void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DialDeviceSelected += x, x => _data.DialDeviceSelected -= x); + }, x => _data.DialDeviceSelected += x, x => _data.DialDeviceSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11761,9 +10563,7 @@ namespace Windows.Media.DialProtocol { void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); } } @@ -11806,9 +10606,7 @@ namespace Windows.Media.Effects { void Handler(global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioCaptureEffectsChanged += x, x => _data.AudioCaptureEffectsChanged -= x); + }, x => _data.AudioCaptureEffectsChanged += x, x => _data.AudioCaptureEffectsChanged -= x); } /// @@ -11833,9 +10631,7 @@ namespace Windows.Media.Effects { void Handler(global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioRenderEffectsChanged += x, x => _data.AudioRenderEffectsChanged -= x); + }, x => _data.AudioRenderEffectsChanged += x, x => _data.AudioRenderEffectsChanged -= x); } } @@ -11874,9 +10670,7 @@ namespace Windows.Media.Import { void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemImported += x, x => _data.ItemImported -= x); + }, x => _data.ItemImported += x, x => _data.ItemImported -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11884,9 +10678,7 @@ namespace Windows.Media.Import { void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } } @@ -11965,9 +10757,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreakEnded += x, x => _data.BreakEnded -= x); + }, x => _data.BreakEnded += x, x => _data.BreakEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11975,9 +10765,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreakSkipped += x, x => _data.BreakSkipped -= x); + }, x => _data.BreakSkipped += x, x => _data.BreakSkipped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11985,9 +10773,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreaksSeekedOver += x, x => _data.BreaksSeekedOver -= x); + }, x => _data.BreaksSeekedOver += x, x => _data.BreaksSeekedOver -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11995,9 +10781,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreakStarted += x, x => _data.BreakStarted -= x); + }, x => _data.BreakStarted += x, x => _data.BreakStarted -= x); } /// @@ -12022,9 +10806,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakSchedule sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScheduleChanged += x, x => _data.ScheduleChanged -= x); + }, x => _data.ScheduleChanged += x, x => _data.ScheduleChanged -= x); } /// @@ -12049,9 +10831,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -12076,9 +10856,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutoRepeatModeReceived += x, x => _data.AutoRepeatModeReceived -= x); + }, x => _data.AutoRepeatModeReceived += x, x => _data.AutoRepeatModeReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12086,9 +10864,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FastForwardReceived += x, x => _data.FastForwardReceived -= x); + }, x => _data.FastForwardReceived += x, x => _data.FastForwardReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12096,9 +10872,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NextReceived += x, x => _data.NextReceived -= x); + }, x => _data.NextReceived += x, x => _data.NextReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12106,9 +10880,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PauseReceived += x, x => _data.PauseReceived -= x); + }, x => _data.PauseReceived += x, x => _data.PauseReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12116,9 +10888,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlayReceived += x, x => _data.PlayReceived -= x); + }, x => _data.PlayReceived += x, x => _data.PlayReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12126,9 +10896,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionReceived += x, x => _data.PositionReceived -= x); + }, x => _data.PositionReceived += x, x => _data.PositionReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12136,9 +10904,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PreviousReceived += x, x => _data.PreviousReceived -= x); + }, x => _data.PreviousReceived += x, x => _data.PreviousReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12146,9 +10912,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RateReceived += x, x => _data.RateReceived -= x); + }, x => _data.RateReceived += x, x => _data.RateReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12156,9 +10920,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RewindReceived += x, x => _data.RewindReceived -= x); + }, x => _data.RewindReceived += x, x => _data.RewindReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12166,9 +10928,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShuffleReceived += x, x => _data.ShuffleReceived -= x); + }, x => _data.ShuffleReceived += x, x => _data.ShuffleReceived -= x); } /// @@ -12193,9 +10953,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); } /// @@ -12220,9 +10978,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioTracksChanged += x, x => _data.AudioTracksChanged -= x); + }, x => _data.AudioTracksChanged += x, x => _data.AudioTracksChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12230,9 +10986,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimedMetadataTracksChanged += x, x => _data.TimedMetadataTracksChanged -= x); + }, x => _data.TimedMetadataTracksChanged += x, x => _data.TimedMetadataTracksChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12240,9 +10994,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoTracksChanged += x, x => _data.VideoTracksChanged -= x); + }, x => _data.VideoTracksChanged += x, x => _data.VideoTracksChanged -= x); } /// @@ -12267,9 +11019,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12277,9 +11027,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemFailed += x, x => _data.ItemFailed -= x); + }, x => _data.ItemFailed += x, x => _data.ItemFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12287,9 +11035,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemOpened += x, x => _data.ItemOpened -= x); + }, x => _data.ItemOpened += x, x => _data.ItemOpened -= x); } /// @@ -12314,9 +11060,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferedRangesChanged += x, x => _data.BufferedRangesChanged -= x); + }, x => _data.BufferedRangesChanged += x, x => _data.BufferedRangesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12324,9 +11068,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12334,9 +11076,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12344,9 +11084,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12354,9 +11092,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12364,9 +11100,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NaturalDurationChanged += x, x => _data.NaturalDurationChanged -= x); + }, x => _data.NaturalDurationChanged += x, x => _data.NaturalDurationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12374,9 +11108,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NaturalVideoSizeChanged += x, x => _data.NaturalVideoSizeChanged -= x); + }, x => _data.NaturalVideoSizeChanged += x, x => _data.NaturalVideoSizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12384,9 +11116,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackRateChanged += x, x => _data.PlaybackRateChanged -= x); + }, x => _data.PlaybackRateChanged += x, x => _data.PlaybackRateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12394,9 +11124,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackStateChanged += x, x => _data.PlaybackStateChanged -= x); + }, x => _data.PlaybackStateChanged += x, x => _data.PlaybackStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12404,9 +11132,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlayedRangesChanged += x, x => _data.PlayedRangesChanged -= x); + }, x => _data.PlayedRangesChanged += x, x => _data.PlayedRangesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12414,9 +11140,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12424,9 +11148,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeekableRangesChanged += x, x => _data.SeekableRangesChanged -= x); + }, x => _data.SeekableRangesChanged += x, x => _data.SeekableRangesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12434,9 +11156,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12444,9 +11164,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SupportedPlaybackRatesChanged += x, x => _data.SupportedPlaybackRatesChanged -= x); + }, x => _data.SupportedPlaybackRatesChanged += x, x => _data.SupportedPlaybackRatesChanged -= x); } /// @@ -12471,9 +11189,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PresentationModeChanged += x, x => _data.PresentationModeChanged -= x); + }, x => _data.PresentationModeChanged += x, x => _data.PresentationModeChanged -= x); } /// @@ -12498,9 +11214,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -12525,9 +11239,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12535,9 +11247,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12545,9 +11255,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12555,9 +11263,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsMutedChanged += x, x => _data.IsMutedChanged -= x); + }, x => _data.IsMutedChanged += x, x => _data.IsMutedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12565,9 +11271,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12575,9 +11279,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12585,9 +11287,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12595,9 +11295,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaPlayerRateChanged += x, x => _data.MediaPlayerRateChanged -= x); + }, x => _data.MediaPlayerRateChanged += x, x => _data.MediaPlayerRateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12605,9 +11303,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackMediaMarkerReached += x, x => _data.PlaybackMediaMarkerReached -= x); + }, x => _data.PlaybackMediaMarkerReached += x, x => _data.PlaybackMediaMarkerReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12615,9 +11311,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12625,9 +11319,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceChanged += x, x => _data.SourceChanged -= x); + }, x => _data.SourceChanged += x, x => _data.SourceChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12635,9 +11327,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SubtitleFrameChanged += x, x => _data.SubtitleFrameChanged -= x); + }, x => _data.SubtitleFrameChanged += x, x => _data.SubtitleFrameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12645,9 +11335,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoFrameAvailable += x, x => _data.VideoFrameAvailable -= x); + }, x => _data.VideoFrameAvailable += x, x => _data.VideoFrameAvailable -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12655,9 +11343,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, double args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoRatioChanged += x, x => _data.VideoRatioChanged -= x); + }, x => _data.VideoRatioChanged += x, x => _data.VideoRatioChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12665,9 +11351,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); } } @@ -12714,9 +11398,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Error += x, x => _data.Error -= x); + }, x => _data.Error += x, x => _data.Error -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12724,9 +11406,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12734,9 +11414,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Transferred += x, x => _data.Transferred -= x); + }, x => _data.Transferred += x, x => _data.Transferred -= x); } /// @@ -12761,9 +11439,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRequested += x, x => _data.SourceRequested -= x); + }, x => _data.SourceRequested += x, x => _data.SourceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12771,9 +11447,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceSelected += x, x => _data.SourceSelected -= x); + }, x => _data.SourceSelected += x, x => _data.SourceSelected -= x); } /// @@ -12798,9 +11472,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentTimeChangeRequested += x, x => _data.CurrentTimeChangeRequested -= x); + }, x => _data.CurrentTimeChangeRequested += x, x => _data.CurrentTimeChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12808,9 +11480,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MuteChangeRequested += x, x => _data.MuteChangeRequested -= x); + }, x => _data.MuteChangeRequested += x, x => _data.MuteChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12818,9 +11488,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PauseRequested += x, x => _data.PauseRequested -= x); + }, x => _data.PauseRequested += x, x => _data.PauseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12828,9 +11496,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12838,9 +11504,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlayRequested += x, x => _data.PlayRequested -= x); + }, x => _data.PlayRequested += x, x => _data.PlayRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12848,9 +11512,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceChangeRequested += x, x => _data.SourceChangeRequested -= x); + }, x => _data.SourceChangeRequested += x, x => _data.SourceChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12858,9 +11520,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StopRequested += x, x => _data.StopRequested -= x); + }, x => _data.StopRequested += x, x => _data.StopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12868,9 +11528,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimeUpdateRequested += x, x => _data.TimeUpdateRequested -= x); + }, x => _data.TimeUpdateRequested += x, x => _data.TimeUpdateRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12878,9 +11536,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VolumeChangeRequested += x, x => _data.VolumeChangeRequested -= x); + }, x => _data.VolumeChangeRequested += x, x => _data.VolumeChangeRequested -= x); } } @@ -12923,9 +11579,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.HdcpSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProtectionChanged += x, x => _data.ProtectionChanged -= x); + }, x => _data.ProtectionChanged += x, x => _data.ProtectionChanged -= x); } /// @@ -12950,9 +11604,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ComponentLoadFailedEventArgs e) => eventHandler((sender, e)); return Handler; - } - - , x => _data.ComponentLoadFailed += x, x => _data.ComponentLoadFailed -= x); + }, x => _data.ComponentLoadFailed += x, x => _data.ComponentLoadFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12960,9 +11612,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.MediaProtectionManager sender) => eventHandler(sender); return Handler; - } - - , x => _data.RebootNeeded += x, x => _data.RebootNeeded -= x); + }, x => _data.RebootNeeded += x, x => _data.RebootNeeded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12970,9 +11620,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ServiceRequestedEventArgs e) => eventHandler((sender, e)); return Handler; - } - - , x => _data.ServiceRequested += x, x => _data.ServiceRequested -= x); + }, x => _data.ServiceRequested += x, x => _data.ServiceRequested -= x); } } @@ -13011,9 +11659,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ClosedCaptionDataReceived += x, x => _data.ClosedCaptionDataReceived -= x); + }, x => _data.ClosedCaptionDataReceived += x, x => _data.ClosedCaptionDataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13021,9 +11667,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LicenseFetchCompleted += x, x => _data.LicenseFetchCompleted -= x); + }, x => _data.LicenseFetchCompleted += x, x => _data.LicenseFetchCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13031,9 +11675,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProximityDetectionCompleted += x, x => _data.ProximityDetectionCompleted -= x); + }, x => _data.ProximityDetectionCompleted += x, x => _data.ProximityDetectionCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13041,9 +11683,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RegistrationCompleted += x, x => _data.RegistrationCompleted -= x); + }, x => _data.RegistrationCompleted += x, x => _data.RegistrationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13051,9 +11691,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReRegistrationNeeded += x, x => _data.ReRegistrationNeeded -= x); + }, x => _data.ReRegistrationNeeded += x, x => _data.ReRegistrationNeeded -= x); } } @@ -13096,9 +11734,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13106,9 +11742,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResultGenerated += x, x => _data.ResultGenerated -= x); + }, x => _data.ResultGenerated += x, x => _data.ResultGenerated -= x); } /// @@ -13133,9 +11767,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HypothesisGenerated += x, x => _data.HypothesisGenerated -= x); + }, x => _data.HypothesisGenerated += x, x => _data.HypothesisGenerated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13143,9 +11775,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RecognitionQualityDegrading += x, x => _data.RecognitionQualityDegrading -= x); + }, x => _data.RecognitionQualityDegrading += x, x => _data.RecognitionQualityDegrading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13153,9 +11783,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -13198,9 +11826,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadBitrateChanged += x, x => _data.DownloadBitrateChanged -= x); + }, x => _data.DownloadBitrateChanged += x, x => _data.DownloadBitrateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13208,9 +11834,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13218,9 +11842,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13228,9 +11850,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadRequested += x, x => _data.DownloadRequested -= x); + }, x => _data.DownloadRequested += x, x => _data.DownloadRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13238,9 +11858,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackBitrateChanged += x, x => _data.PlaybackBitrateChanged -= x); + }, x => _data.PlaybackBitrateChanged += x, x => _data.PlaybackBitrateChanged -= x); } /// @@ -13265,9 +11883,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DiagnosticAvailable += x, x => _data.DiagnosticAvailable -= x); + }, x => _data.DiagnosticAvailable += x, x => _data.DiagnosticAvailable -= x); } } @@ -13306,9 +11922,7 @@ namespace Windows.Networking.BackgroundTransfer { void Handler(global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RangesDownloaded += x, x => _data.RangesDownloaded -= x); + }, x => _data.RangesDownloaded += x, x => _data.RangesDownloaded -= x); } } @@ -13371,9 +11985,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESim sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProfileChanged += x, x => _data.ProfileChanged -= x); + }, x => _data.ProfileChanged += x, x => _data.ProfileChanged -= x); } /// @@ -13398,9 +12010,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -13425,9 +12035,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13435,9 +12043,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13445,9 +12051,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13455,9 +12059,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13465,9 +12067,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -13492,9 +12092,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountAdded += x, x => _data.AccountAdded -= x); + }, x => _data.AccountAdded += x, x => _data.AccountAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13502,9 +12100,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountRemoved += x, x => _data.AccountRemoved -= x); + }, x => _data.AccountRemoved += x, x => _data.AccountRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13512,9 +12108,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountUpdated += x, x => _data.AccountUpdated -= x); + }, x => _data.AccountUpdated += x, x => _data.AccountUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13522,9 +12116,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13532,9 +12124,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -13559,9 +12149,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); } /// @@ -13586,9 +12174,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsInEmergencyCallModeChanged += x, x => _data.IsInEmergencyCallModeChanged -= x); + }, x => _data.IsInEmergencyCallModeChanged += x, x => _data.IsInEmergencyCallModeChanged -= x); } /// @@ -13613,9 +12199,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TransmissionStateChanged += x, x => _data.TransmissionStateChanged -= x); + }, x => _data.TransmissionStateChanged += x, x => _data.TransmissionStateChanged -= x); } } @@ -13658,9 +12242,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13668,9 +12250,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13678,9 +12258,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13688,9 +12266,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13698,9 +12274,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -13725,9 +12299,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); return Handler; - } - - , x => _data.DeviceArrived += x, x => _data.DeviceArrived -= x); + }, x => _data.DeviceArrived += x, x => _data.DeviceArrived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13735,9 +12307,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); return Handler; - } - - , x => _data.DeviceDeparted += x, x => _data.DeviceDeparted -= x); + }, x => _data.DeviceDeparted += x, x => _data.DeviceDeparted -= x); } } @@ -13776,9 +12346,7 @@ namespace Windows.Networking.PushNotifications { void Handler(global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PushNotificationReceived += x, x => _data.PushNotificationReceived -= x); + }, x => _data.PushNotificationReceived += x, x => _data.PushNotificationReceived -= x); } } @@ -13817,9 +12385,7 @@ namespace Windows.Networking.ServiceDiscovery.Dnssd { void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13827,9 +12393,7 @@ namespace Windows.Networking.ServiceDiscovery.Dnssd { void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13837,9 +12401,7 @@ namespace Windows.Networking.ServiceDiscovery.Dnssd { void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -13902,9 +12464,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } /// @@ -13929,9 +12489,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } /// @@ -13956,9 +12514,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13966,9 +12522,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13976,9 +12530,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); } /// @@ -14003,9 +12555,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14013,9 +12563,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } /// @@ -14040,9 +12588,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } /// @@ -14067,9 +12613,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionReceived += x, x => _data.ConnectionReceived -= x); + }, x => _data.ConnectionReceived += x, x => _data.ConnectionReceived -= x); } /// @@ -14094,9 +12638,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14104,9 +12646,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); } } @@ -14145,9 +12685,7 @@ namespace Windows.Networking.Vpn { void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActivityChange += x, x => _data.ActivityChange -= x); + }, x => _data.ActivityChange += x, x => _data.ActivityChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14155,9 +12693,7 @@ namespace Windows.Networking.Vpn { void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActivityStateChange += x, x => _data.ActivityStateChange -= x); + }, x => _data.ActivityStateChange += x, x => _data.ActivityStateChange -= x); } } @@ -14204,9 +12740,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RawCoordinateSystemAdjusted += x, x => _data.RawCoordinateSystemAdjusted -= x); + }, x => _data.RawCoordinateSystemAdjusted += x, x => _data.RawCoordinateSystemAdjusted -= x); } /// @@ -14231,9 +12765,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14241,9 +12773,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14251,9 +12781,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14261,9 +12789,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -14288,9 +12814,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LocatabilityChanged += x, x => _data.LocatabilityChanged -= x); + }, x => _data.LocatabilityChanged += x, x => _data.LocatabilityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14298,9 +12822,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionalTrackingDeactivating += x, x => _data.PositionalTrackingDeactivating -= x); + }, x => _data.PositionalTrackingDeactivating += x, x => _data.PositionalTrackingDeactivating -= x); } } @@ -14339,9 +12861,7 @@ namespace Windows.Perception.Spatial.Surfaces { void Handler(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ObservedSurfacesChanged += x, x => _data.ObservedSurfacesChanged -= x); + }, x => _data.ObservedSurfacesChanged += x, x => _data.ObservedSurfacesChanged -= x); } } @@ -14380,9 +12900,7 @@ namespace Windows.Phone.Devices.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingChargePercentChanged += x, x => _data.RemainingChargePercentChanged -= x); + }, x => _data.RemainingChargePercentChanged += x, x => _data.RemainingChargePercentChanged -= x); } } @@ -14421,9 +12939,7 @@ namespace Windows.Phone.Media.Devices { void Handler(global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioEndpointChanged += x, x => _data.AudioEndpointChanged -= x); + }, x => _data.AudioEndpointChanged += x, x => _data.AudioEndpointChanged -= x); } } @@ -14462,9 +12978,7 @@ namespace Windows.Security.Authentication.Web.Core { void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DefaultSignInAccountChanged += x, x => _data.DefaultSignInAccountChanged -= x); + }, x => _data.DefaultSignInAccountChanged += x, x => _data.DefaultSignInAccountChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14472,9 +12986,7 @@ namespace Windows.Security.Authentication.Web.Core { void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14482,9 +12994,7 @@ namespace Windows.Security.Authentication.Web.Core { void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -14523,9 +13033,7 @@ namespace Windows.Security.Credentials { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } } @@ -14564,9 +13072,7 @@ namespace Windows.Services.Maps.OfflineMaps { void Handler(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } } @@ -14617,9 +13123,7 @@ namespace Windows.Storage { void Handler(global::Windows.Storage.ApplicationData sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataChanged += x, x => _data.DataChanged -= x); + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); } /// @@ -14644,9 +13148,7 @@ namespace Windows.Storage { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -14671,9 +13173,7 @@ namespace Windows.Storage { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -14698,9 +13198,7 @@ namespace Windows.Storage { void Handler(global::Windows.Storage.StorageLibrary sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DefinitionChanged += x, x => _data.DefinitionChanged -= x); + }, x => _data.DefinitionChanged += x, x => _data.DefinitionChanged -= x); } } @@ -14739,9 +13237,7 @@ namespace Windows.Storage.AccessCache { void Handler(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); } } @@ -14788,9 +13284,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14798,9 +13292,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); } /// @@ -14825,9 +13317,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14835,9 +13325,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); } /// @@ -14862,9 +13350,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14872,9 +13358,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); } } @@ -14917,9 +13401,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14927,9 +13409,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileRemoved += x, x => _data.FileRemoved -= x); + }, x => _data.FileRemoved += x, x => _data.FileRemoved -= x); } /// @@ -14954,9 +13434,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileNameChanged += x, x => _data.FileNameChanged -= x); + }, x => _data.FileNameChanged += x, x => _data.FileNameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14964,9 +13442,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetFileRequested += x, x => _data.TargetFileRequested -= x); + }, x => _data.TargetFileRequested += x, x => _data.TargetFileRequested -= x); } } @@ -15005,9 +13481,7 @@ namespace Windows.Storage.Provider { void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileUpdateRequested += x, x => _data.FileUpdateRequested -= x); + }, x => _data.FileUpdateRequested += x, x => _data.FileUpdateRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15015,9 +13489,7 @@ namespace Windows.Storage.Provider { void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UIRequested += x, x => _data.UIRequested -= x); + }, x => _data.UIRequested += x, x => _data.UIRequested -= x); } } @@ -15068,9 +13540,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15078,9 +13548,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } /// @@ -15105,9 +13573,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15115,9 +13581,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } /// @@ -15142,9 +13606,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15152,9 +13614,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } /// @@ -15179,9 +13639,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15189,9 +13647,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } } @@ -15246,9 +13702,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15256,9 +13710,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15266,9 +13718,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15276,9 +13726,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -15303,9 +13751,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15313,9 +13759,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15323,9 +13767,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ExecutionStateChanged += x, x => _data.ExecutionStateChanged -= x); + }, x => _data.ExecutionStateChanged += x, x => _data.ExecutionStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15333,9 +13775,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15343,9 +13783,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -15370,9 +13808,7 @@ namespace Windows.System { void Handler(global::Windows.System.DispatcherQueue sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShutdownCompleted += x, x => _data.ShutdownCompleted -= x); + }, x => _data.ShutdownCompleted += x, x => _data.ShutdownCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15380,9 +13816,7 @@ namespace Windows.System { void Handler(global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShutdownStarting += x, x => _data.ShutdownStarting -= x); + }, x => _data.ShutdownStarting += x, x => _data.ShutdownStarting -= x); } /// @@ -15407,9 +13841,7 @@ namespace Windows.System { void Handler(global::Windows.System.DispatcherQueueTimer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// @@ -15434,9 +13866,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15444,9 +13874,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AuthenticationStatusChanged += x, x => _data.AuthenticationStatusChanged -= x); + }, x => _data.AuthenticationStatusChanged += x, x => _data.AuthenticationStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15454,9 +13882,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AuthenticationStatusChanging += x, x => _data.AuthenticationStatusChanging -= x); + }, x => _data.AuthenticationStatusChanging += x, x => _data.AuthenticationStatusChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15464,9 +13890,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15474,9 +13898,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15484,9 +13906,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15494,9 +13914,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -15535,9 +13953,7 @@ namespace Windows.System.Diagnostics.DevicePortal { void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15545,9 +13961,7 @@ namespace Windows.System.Diagnostics.DevicePortal { void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); } } @@ -15586,9 +14000,7 @@ namespace Windows.System.Preview { void Handler(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PostureChanged += x, x => _data.PostureChanged -= x); + }, x => _data.PostureChanged += x, x => _data.PostureChanged -= x); } } @@ -15651,9 +14063,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Disconnected += x, x => _data.Disconnected -= x); + }, x => _data.Disconnected += x, x => _data.Disconnected -= x); } /// @@ -15678,9 +14088,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.JoinRequested += x, x => _data.JoinRequested -= x); + }, x => _data.JoinRequested += x, x => _data.JoinRequested -= x); } /// @@ -15705,9 +14113,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InvitationReceived += x, x => _data.InvitationReceived -= x); + }, x => _data.InvitationReceived += x, x => _data.InvitationReceived -= x); } /// @@ -15732,9 +14138,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValueSetReceived += x, x => _data.ValueSetReceived -= x); + }, x => _data.ValueSetReceived += x, x => _data.ValueSetReceived -= x); } /// @@ -15759,9 +14163,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15769,9 +14171,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15779,9 +14179,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); } /// @@ -15806,9 +14204,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15816,9 +14212,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15826,9 +14220,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -15853,9 +14245,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15863,9 +14253,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15873,9 +14261,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteSystemAdded += x, x => _data.RemoteSystemAdded -= x); + }, x => _data.RemoteSystemAdded += x, x => _data.RemoteSystemAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15883,9 +14269,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteSystemRemoved += x, x => _data.RemoteSystemRemoved -= x); + }, x => _data.RemoteSystemRemoved += x, x => _data.RemoteSystemRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15893,9 +14277,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteSystemUpdated += x, x => _data.RemoteSystemUpdated -= x); + }, x => _data.RemoteSystemUpdated += x, x => _data.RemoteSystemUpdated -= x); } } @@ -15934,9 +14316,7 @@ namespace Windows.UI.Accessibility { void Handler(global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenReaderPositionChanged += x, x => _data.ScreenReaderPositionChanged -= x); + }, x => _data.ScreenReaderPositionChanged += x, x => _data.ScreenReaderPositionChanged -= x); } } @@ -15975,9 +14355,7 @@ namespace Windows.UI.ApplicationSettings { void Handler(global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountCommandsRequested += x, x => _data.AccountCommandsRequested -= x); + }, x => _data.AccountCommandsRequested += x, x => _data.AccountCommandsRequested -= x); } } @@ -16028,9 +14406,7 @@ namespace Windows.UI.Composition { void Handler(global::Windows.UI.Composition.CompositionCapabilities sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } /// @@ -16055,9 +14431,7 @@ namespace Windows.UI.Composition { void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -16082,9 +14456,7 @@ namespace Windows.UI.Composition { void Handler(global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RenderingDeviceReplaced += x, x => _data.RenderingDeviceReplaced -= x); + }, x => _data.RenderingDeviceReplaced += x, x => _data.RenderingDeviceReplaced -= x); } /// @@ -16109,9 +14481,7 @@ namespace Windows.UI.Composition { void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } } @@ -16150,9 +14520,7 @@ namespace Windows.UI.Composition.Core { void Handler(global::Windows.UI.Composition.Core.CompositorController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CommitNeeded += x, x => _data.CommitNeeded -= x); + }, x => _data.CommitNeeded += x, x => _data.CommitNeeded -= x); } } @@ -16231,9 +14599,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); } /// @@ -16258,9 +14624,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16268,9 +14632,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16278,9 +14640,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16288,9 +14648,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16298,9 +14656,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16308,9 +14664,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16318,9 +14672,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16328,9 +14680,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16338,9 +14688,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16348,9 +14696,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16358,9 +14704,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16368,9 +14712,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16378,9 +14720,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16388,9 +14728,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16398,9 +14736,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); } /// @@ -16425,9 +14761,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); } /// @@ -16452,9 +14786,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16462,9 +14794,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16472,9 +14802,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16482,9 +14810,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16492,9 +14818,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16502,9 +14826,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16512,9 +14834,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16522,9 +14842,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); } /// @@ -16549,9 +14867,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16559,9 +14875,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16569,9 +14883,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16579,9 +14891,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16589,9 +14899,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16599,9 +14907,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16609,9 +14915,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16619,9 +14923,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16629,9 +14931,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16639,9 +14939,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16649,9 +14947,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16659,9 +14955,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16669,9 +14963,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16679,9 +14971,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16689,9 +14979,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16699,9 +14987,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16709,9 +14995,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16719,9 +15003,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16729,9 +15011,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResizeCompleted += x, x => _data.ResizeCompleted -= x); + }, x => _data.ResizeCompleted += x, x => _data.ResizeCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16739,9 +15019,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResizeStarted += x, x => _data.ResizeStarted -= x); + }, x => _data.ResizeStarted += x, x => _data.ResizeStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16749,9 +15027,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16759,9 +15035,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16769,9 +15043,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } /// @@ -16796,9 +15068,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); } /// @@ -16823,9 +15093,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); } /// @@ -16850,9 +15118,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16860,9 +15126,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16870,9 +15134,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16880,9 +15142,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16890,9 +15150,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16900,9 +15158,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16910,9 +15166,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); } /// @@ -16937,9 +15191,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16947,9 +15199,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16957,9 +15207,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); } /// @@ -16984,9 +15232,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16994,9 +15240,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17004,9 +15248,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17014,9 +15256,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17024,9 +15264,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17034,9 +15272,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17044,9 +15280,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17054,9 +15288,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17064,9 +15296,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17074,9 +15304,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17084,9 +15312,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17094,9 +15320,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17104,9 +15328,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17114,9 +15336,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17124,9 +15344,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17134,9 +15352,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17144,9 +15360,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } /// @@ -17171,9 +15385,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.BackRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackRequested += x, x => _data.BackRequested -= x); + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); } } @@ -17212,9 +15424,7 @@ namespace Windows.UI.Core.Preview { void Handler(object sender, global::Windows.UI.Core.Preview.SystemNavigationCloseRequestedPreviewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); } } @@ -17269,9 +15479,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17279,9 +15487,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17289,9 +15495,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Starting += x, x => _data.Starting -= x); + }, x => _data.Starting += x, x => _data.Starting -= x); } /// @@ -17316,9 +15520,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CrossSliding += x, x => _data.CrossSliding -= x); + }, x => _data.CrossSliding += x, x => _data.CrossSliding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17326,9 +15528,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Dragging += x, x => _data.Dragging -= x); + }, x => _data.Dragging += x, x => _data.Dragging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17336,9 +15536,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Holding += x, x => _data.Holding -= x); + }, x => _data.Holding += x, x => _data.Holding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17346,9 +15544,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17356,9 +15552,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17366,9 +15560,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17376,9 +15568,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17386,9 +15576,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RightTapped += x, x => _data.RightTapped -= x); + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17396,9 +15584,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -17423,9 +15609,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17433,9 +15617,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); } /// @@ -17460,9 +15642,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonClicked += x, x => _data.ButtonClicked -= x); + }, x => _data.ButtonClicked += x, x => _data.ButtonClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17470,9 +15650,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonHolding += x, x => _data.ButtonHolding -= x); + }, x => _data.ButtonHolding += x, x => _data.ButtonHolding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17480,9 +15658,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17490,9 +15666,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonReleased += x, x => _data.ButtonReleased -= x); + }, x => _data.ButtonReleased += x, x => _data.ButtonReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17500,9 +15674,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ControlAcquired += x, x => _data.ControlAcquired -= x); + }, x => _data.ControlAcquired += x, x => _data.ControlAcquired -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17510,9 +15682,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ControlLost += x, x => _data.ControlLost -= x); + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17520,9 +15690,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RotationChanged += x, x => _data.RotationChanged -= x); + }, x => _data.RotationChanged += x, x => _data.RotationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17530,9 +15698,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenContactContinued += x, x => _data.ScreenContactContinued -= x); + }, x => _data.ScreenContactContinued += x, x => _data.ScreenContactContinued -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17540,9 +15706,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenContactEnded += x, x => _data.ScreenContactEnded -= x); + }, x => _data.ScreenContactEnded += x, x => _data.ScreenContactEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17550,9 +15714,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenContactStarted += x, x => _data.ScreenContactStarted -= x); + }, x => _data.ScreenContactStarted += x, x => _data.ScreenContactStarted -= x); } /// @@ -17577,9 +15739,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialControllerMenuItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } } @@ -17626,9 +15786,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokesCollected += x, x => _data.StrokesCollected -= x); + }, x => _data.StrokesCollected += x, x => _data.StrokesCollected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17636,9 +15794,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokesErased += x, x => _data.StrokesErased -= x); + }, x => _data.StrokesErased += x, x => _data.StrokesErased -= x); } /// @@ -17663,9 +15819,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeCanceled += x, x => _data.StrokeCanceled -= x); + }, x => _data.StrokeCanceled += x, x => _data.StrokeCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17673,9 +15827,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeContinued += x, x => _data.StrokeContinued -= x); + }, x => _data.StrokeContinued += x, x => _data.StrokeContinued -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17683,9 +15835,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeEnded += x, x => _data.StrokeEnded -= x); + }, x => _data.StrokeEnded += x, x => _data.StrokeEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17693,9 +15843,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeStarted += x, x => _data.StrokeStarted -= x); + }, x => _data.StrokeStarted += x, x => _data.StrokeStarted -= x); } /// @@ -17720,9 +15868,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17730,9 +15876,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17740,9 +15884,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerHovered += x, x => _data.PointerHovered -= x); + }, x => _data.PointerHovered += x, x => _data.PointerHovered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17750,9 +15892,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerLost += x, x => _data.PointerLost -= x); + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17760,9 +15900,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17770,9 +15908,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17780,9 +15916,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); } } @@ -17825,9 +15959,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntering += x, x => _data.PointerEntering -= x); + }, x => _data.PointerEntering += x, x => _data.PointerEntering -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17835,9 +15967,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExiting += x, x => _data.PointerExiting -= x); + }, x => _data.PointerExiting += x, x => _data.PointerExiting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17845,9 +15975,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerHovering += x, x => _data.PointerHovering -= x); + }, x => _data.PointerHovering += x, x => _data.PointerHovering -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17855,9 +15983,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerLost += x, x => _data.PointerLost -= x); + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17865,9 +15991,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoving += x, x => _data.PointerMoving -= x); + }, x => _data.PointerMoving += x, x => _data.PointerMoving -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17875,9 +15999,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressing += x, x => _data.PointerPressing -= x); + }, x => _data.PointerPressing += x, x => _data.PointerPressing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17885,9 +16007,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleasing += x, x => _data.PointerReleasing -= x); + }, x => _data.PointerReleasing += x, x => _data.PointerReleasing -= x); } /// @@ -17912,9 +16032,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeCanceled += x, x => _data.WetStrokeCanceled -= x); + }, x => _data.WetStrokeCanceled += x, x => _data.WetStrokeCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17922,9 +16040,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeCompleted += x, x => _data.WetStrokeCompleted -= x); + }, x => _data.WetStrokeCompleted += x, x => _data.WetStrokeCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17932,9 +16048,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeContinuing += x, x => _data.WetStrokeContinuing -= x); + }, x => _data.WetStrokeContinuing += x, x => _data.WetStrokeContinuing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17942,9 +16056,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeStarting += x, x => _data.WetStrokeStarting -= x); + }, x => _data.WetStrokeStarting += x, x => _data.WetStrokeStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17952,9 +16064,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeStopping += x, x => _data.WetStrokeStopping -= x); + }, x => _data.WetStrokeStopping += x, x => _data.WetStrokeStopping -= x); } } @@ -17997,9 +16107,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HoldCanceled += x, x => _data.HoldCanceled -= x); + }, x => _data.HoldCanceled += x, x => _data.HoldCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18007,9 +16115,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HoldCompleted += x, x => _data.HoldCompleted -= x); + }, x => _data.HoldCompleted += x, x => _data.HoldCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18017,9 +16123,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HoldStarted += x, x => _data.HoldStarted -= x); + }, x => _data.HoldStarted += x, x => _data.HoldStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18027,9 +16131,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationCanceled += x, x => _data.ManipulationCanceled -= x); + }, x => _data.ManipulationCanceled += x, x => _data.ManipulationCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18037,9 +16139,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18047,9 +16147,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18057,9 +16155,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18067,9 +16163,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCanceled += x, x => _data.NavigationCanceled -= x); + }, x => _data.NavigationCanceled += x, x => _data.NavigationCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18077,9 +16171,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18087,9 +16179,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarted += x, x => _data.NavigationStarted -= x); + }, x => _data.NavigationStarted += x, x => _data.NavigationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18097,9 +16187,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationUpdated += x, x => _data.NavigationUpdated -= x); + }, x => _data.NavigationUpdated += x, x => _data.NavigationUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18107,9 +16195,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RecognitionEnded += x, x => _data.RecognitionEnded -= x); + }, x => _data.RecognitionEnded += x, x => _data.RecognitionEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18117,9 +16203,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RecognitionStarted += x, x => _data.RecognitionStarted -= x); + }, x => _data.RecognitionStarted += x, x => _data.RecognitionStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18127,9 +16211,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -18154,9 +16236,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InteractionDetected += x, x => _data.InteractionDetected -= x); + }, x => _data.InteractionDetected += x, x => _data.InteractionDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18164,9 +16244,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceDetected += x, x => _data.SourceDetected -= x); + }, x => _data.SourceDetected += x, x => _data.SourceDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18174,9 +16252,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceLost += x, x => _data.SourceLost -= x); + }, x => _data.SourceLost += x, x => _data.SourceLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18184,9 +16260,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourcePressed += x, x => _data.SourcePressed -= x); + }, x => _data.SourcePressed += x, x => _data.SourcePressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18194,9 +16268,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceReleased += x, x => _data.SourceReleased -= x); + }, x => _data.SourceReleased += x, x => _data.SourceReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18204,9 +16276,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); } } @@ -18249,9 +16319,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotification sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18259,9 +16327,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18269,9 +16335,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Failed += x, x => _data.Failed -= x); + }, x => _data.Failed += x, x => _data.Failed -= x); } /// @@ -18296,9 +16360,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScheduledToastNotificationShowing += x, x => _data.ScheduledToastNotificationShowing -= x); + }, x => _data.ScheduledToastNotificationShowing += x, x => _data.ScheduledToastNotificationShowing -= x); } } @@ -18337,9 +16399,7 @@ namespace Windows.UI.Notifications.Management { void Handler(global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NotificationChanged += x, x => _data.NotificationChanged -= x); + }, x => _data.NotificationChanged += x, x => _data.NotificationChanged -= x); } } @@ -18378,9 +16438,7 @@ namespace Windows.UI.StartScreen { void Handler(global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisualElementsRequested += x, x => _data.VisualElementsRequested -= x); + }, x => _data.VisualElementsRequested += x, x => _data.VisualElementsRequested -= x); } } @@ -18423,9 +16481,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompositionCompleted += x, x => _data.CompositionCompleted -= x); + }, x => _data.CompositionCompleted += x, x => _data.CompositionCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18433,9 +16489,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompositionStarted += x, x => _data.CompositionStarted -= x); + }, x => _data.CompositionStarted += x, x => _data.CompositionStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18443,9 +16497,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusRemoved += x, x => _data.FocusRemoved -= x); + }, x => _data.FocusRemoved += x, x => _data.FocusRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18453,9 +16505,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FormatUpdating += x, x => _data.FormatUpdating -= x); + }, x => _data.FormatUpdating += x, x => _data.FormatUpdating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18463,9 +16513,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LayoutRequested += x, x => _data.LayoutRequested -= x); + }, x => _data.LayoutRequested += x, x => _data.LayoutRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18473,9 +16521,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NotifyFocusLeaveCompleted += x, x => _data.NotifyFocusLeaveCompleted -= x); + }, x => _data.NotifyFocusLeaveCompleted += x, x => _data.NotifyFocusLeaveCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18483,9 +16529,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionRequested += x, x => _data.SelectionRequested -= x); + }, x => _data.SelectionRequested += x, x => _data.SelectionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18493,9 +16537,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionUpdating += x, x => _data.SelectionUpdating -= x); + }, x => _data.SelectionUpdating += x, x => _data.SelectionUpdating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18503,9 +16545,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextRequested += x, x => _data.TextRequested -= x); + }, x => _data.TextRequested += x, x => _data.TextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18513,9 +16553,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextUpdating += x, x => _data.TextUpdating -= x); + }, x => _data.TextUpdating += x, x => _data.TextUpdating -= x); } /// @@ -18540,9 +16578,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); } } @@ -18597,9 +16633,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HighContrastChanged += x, x => _data.HighContrastChanged -= x); + }, x => _data.HighContrastChanged += x, x => _data.HighContrastChanged -= x); } /// @@ -18624,9 +16658,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Consolidated += x, x => _data.Consolidated -= x); + }, x => _data.Consolidated += x, x => _data.Consolidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18634,9 +16666,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisibleBoundsChanged += x, x => _data.VisibleBoundsChanged -= x); + }, x => _data.VisibleBoundsChanged += x, x => _data.VisibleBoundsChanged -= x); } /// @@ -18661,9 +16691,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Hiding += x, x => _data.Hiding -= x); + }, x => _data.Hiding += x, x => _data.Hiding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18671,9 +16699,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Showing += x, x => _data.Showing -= x); + }, x => _data.Showing += x, x => _data.Showing -= x); } /// @@ -18698,9 +16724,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Hiding += x, x => _data.Hiding -= x); + }, x => _data.Hiding += x, x => _data.Hiding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18708,9 +16732,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Showing += x, x => _data.Showing -= x); + }, x => _data.Showing += x, x => _data.Showing -= x); } /// @@ -18735,9 +16757,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvancedEffectsEnabledChanged += x, x => _data.AdvancedEffectsEnabledChanged -= x); + }, x => _data.AdvancedEffectsEnabledChanged += x, x => _data.AdvancedEffectsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18745,9 +16765,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorValuesChanged += x, x => _data.ColorValuesChanged -= x); + }, x => _data.ColorValuesChanged += x, x => _data.ColorValuesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18755,9 +16773,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextScaleFactorChanged += x, x => _data.TextScaleFactorChanged -= x); + }, x => _data.TextScaleFactorChanged += x, x => _data.TextScaleFactorChanged -= x); } } @@ -18796,9 +16812,7 @@ namespace Windows.UI.ViewManagement.Core { void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OcclusionsChanged += x, x => _data.OcclusionsChanged -= x); + }, x => _data.OcclusionsChanged += x, x => _data.OcclusionsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18806,9 +16820,7 @@ namespace Windows.UI.ViewManagement.Core { void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.XYFocusTransferredToPrimaryView += x, x => _data.XYFocusTransferredToPrimaryView -= x); + }, x => _data.XYFocusTransferredToPrimaryView += x, x => _data.XYFocusTransferredToPrimaryView -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18816,9 +16828,7 @@ namespace Windows.UI.ViewManagement.Core { void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.XYFocusTransferringFromPrimaryView += x, x => _data.XYFocusTransferringFromPrimaryView -= x); + }, x => _data.XYFocusTransferringFromPrimaryView += x, x => _data.XYFocusTransferringFromPrimaryView -= x); } } @@ -18861,9 +16871,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); } /// @@ -18888,9 +16896,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18898,9 +16904,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.UI.WebUI.WebUIView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18908,9 +16912,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18918,9 +16920,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18928,9 +16928,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18938,9 +16936,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18948,9 +16944,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18958,9 +16952,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18968,9 +16960,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18978,9 +16968,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18988,9 +16976,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18998,9 +16984,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19008,9 +16992,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19018,9 +17000,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19028,9 +17008,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19038,9 +17016,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19048,9 +17024,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19058,9 +17032,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19068,9 +17040,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } } @@ -19189,9 +17159,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EnteredBackground += x, x => _data.EnteredBackground -= x); + }, x => _data.EnteredBackground += x, x => _data.EnteredBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19199,9 +17167,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LeavingBackground += x, x => _data.LeavingBackground -= x); + }, x => _data.LeavingBackground += x, x => _data.LeavingBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19209,9 +17175,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Resuming += x, x => _data.Resuming -= x); + }, x => _data.Resuming += x, x => _data.Resuming -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19219,9 +17183,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Suspending += x, x => _data.Suspending -= x); + }, x => _data.Suspending += x, x => _data.Suspending -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19229,9 +17191,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.UnhandledExceptionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); } /// @@ -19256,9 +17216,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19283,9 +17241,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.BindingFailedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingFailed += x, x => _data.BindingFailed -= x); + }, x => _data.BindingFailed += x, x => _data.BindingFailed -= x); } /// @@ -19310,9 +17266,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19337,9 +17291,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// @@ -19364,9 +17316,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.FrameworkElement sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActualThemeChanged += x, x => _data.ActualThemeChanged -= x); + }, x => _data.ActualThemeChanged += x, x => _data.ActualThemeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19374,9 +17324,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EffectiveViewportChanged += x, x => _data.EffectiveViewportChanged -= x); + }, x => _data.EffectiveViewportChanged += x, x => _data.EffectiveViewportChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19384,9 +17332,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19394,9 +17340,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19404,9 +17348,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19414,9 +17356,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19424,9 +17364,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19434,9 +17372,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19444,9 +17380,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19454,9 +17388,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -19481,9 +17413,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19508,9 +17438,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19518,9 +17446,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19528,9 +17454,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19538,9 +17462,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -19565,9 +17487,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19592,9 +17512,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19619,9 +17537,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19646,9 +17562,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19673,9 +17587,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19700,9 +17612,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19727,9 +17637,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19754,9 +17662,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19764,9 +17670,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19774,9 +17678,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19784,9 +17686,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BringIntoViewRequested += x, x => _data.BringIntoViewRequested -= x); + }, x => _data.BringIntoViewRequested += x, x => _data.BringIntoViewRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19794,9 +17694,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19804,9 +17702,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContextCanceled += x, x => _data.ContextCanceled -= x); + }, x => _data.ContextCanceled += x, x => _data.ContextCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19814,9 +17710,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContextRequested += x, x => _data.ContextRequested -= x); + }, x => _data.ContextRequested += x, x => _data.ContextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19824,9 +17718,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); + }, x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19834,9 +17726,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragEnter += x, x => _data.DragEnter -= x); + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19844,9 +17734,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragLeave += x, x => _data.DragLeave -= x); + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19854,9 +17742,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragOver += x, x => _data.DragOver -= x); + }, x => _data.DragOver += x, x => _data.DragOver -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19864,9 +17750,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragStarting += x, x => _data.DragStarting -= x); + }, x => _data.DragStarting += x, x => _data.DragStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19874,9 +17758,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drop += x, x => _data.Drop -= x); + }, x => _data.Drop += x, x => _data.Drop -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19884,9 +17766,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DropCompleted += x, x => _data.DropCompleted -= x); + }, x => _data.DropCompleted += x, x => _data.DropCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19894,9 +17774,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GettingFocus += x, x => _data.GettingFocus -= x); + }, x => _data.GettingFocus += x, x => _data.GettingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19904,9 +17782,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19914,9 +17790,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.HoldingRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Holding += x, x => _data.Holding -= x); + }, x => _data.Holding += x, x => _data.Holding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19924,9 +17798,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19934,9 +17806,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19944,9 +17814,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19954,9 +17822,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19964,9 +17830,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19974,9 +17838,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19984,9 +17846,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19994,9 +17854,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20004,9 +17862,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20014,9 +17870,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NoFocusCandidateFound += x, x => _data.NoFocusCandidateFound -= x); + }, x => _data.NoFocusCandidateFound += x, x => _data.NoFocusCandidateFound -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20024,9 +17878,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerCanceled += x, x => _data.PointerCanceled -= x); + }, x => _data.PointerCanceled += x, x => _data.PointerCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20034,9 +17886,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20044,9 +17894,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20054,9 +17902,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20064,9 +17910,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20074,9 +17918,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20084,9 +17926,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20094,9 +17934,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20104,9 +17942,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20114,9 +17950,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20124,9 +17958,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProcessKeyboardAccelerators += x, x => _data.ProcessKeyboardAccelerators -= x); + }, x => _data.ProcessKeyboardAccelerators += x, x => _data.ProcessKeyboardAccelerators -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20134,9 +17966,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.RightTappedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RightTapped += x, x => _data.RightTapped -= x); + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20144,9 +17974,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.TappedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -20171,9 +17999,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20198,9 +18024,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20208,9 +18032,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20218,9 +18040,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20245,9 +18065,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20272,9 +18090,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20299,9 +18115,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.WindowActivatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20309,9 +18123,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20319,9 +18131,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.WindowSizeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20329,9 +18139,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.VisibilityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } } @@ -20370,9 +18178,7 @@ namespace Windows.UI.Xaml.Automation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -20415,9 +18221,7 @@ namespace Windows.UI.Xaml.Automation.Peers { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20442,9 +18246,7 @@ namespace Windows.UI.Xaml.Automation.Peers { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -20483,9 +18285,7 @@ namespace Windows.UI.Xaml.Automation.Provider { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -20848,9 +18648,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20858,9 +18656,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20868,9 +18664,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20878,9 +18672,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opening += x, x => _data.Opening -= x); + }, x => _data.Opening += x, x => _data.Opening -= x); } /// @@ -20905,9 +18697,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20915,9 +18705,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SuggestionChosen += x, x => _data.SuggestionChosen -= x); + }, x => _data.SuggestionChosen += x, x => _data.SuggestionChosen -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20925,9 +18713,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -20952,9 +18738,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20979,9 +18763,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21006,9 +18788,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21033,9 +18813,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs e) => eventHandler((sender, e)); return Handler; - } - - , x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21043,9 +18821,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21053,9 +18829,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DateChanged += x, x => _data.DateChanged -= x); + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21063,9 +18837,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -21090,9 +18862,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21100,9 +18870,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); } /// @@ -21127,9 +18895,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); } /// @@ -21154,9 +18920,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21181,9 +18945,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21191,9 +18953,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21201,9 +18961,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextSubmitted += x, x => _data.TextSubmitted -= x); + }, x => _data.TextSubmitted += x, x => _data.TextSubmitted -= x); } /// @@ -21228,9 +18986,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DynamicOverflowItemsChanging += x, x => _data.DynamicOverflowItemsChanging -= x); + }, x => _data.DynamicOverflowItemsChanging += x, x => _data.DynamicOverflowItemsChanging -= x); } /// @@ -21255,9 +19011,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CloseButtonClick += x, x => _data.CloseButtonClick -= x); + }, x => _data.CloseButtonClick += x, x => _data.CloseButtonClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21265,9 +19019,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21275,9 +19027,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21285,9 +19035,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21295,9 +19043,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrimaryButtonClick += x, x => _data.PrimaryButtonClick -= x); + }, x => _data.PrimaryButtonClick += x, x => _data.PrimaryButtonClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21305,9 +19051,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SecondaryButtonClick += x, x => _data.SecondaryButtonClick -= x); + }, x => _data.SecondaryButtonClick += x, x => _data.SecondaryButtonClick -= x); } /// @@ -21332,9 +19076,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusDisengaged += x, x => _data.FocusDisengaged -= x); + }, x => _data.FocusDisengaged += x, x => _data.FocusDisengaged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21342,9 +19084,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusEngaged += x, x => _data.FocusEngaged -= x); + }, x => _data.FocusEngaged += x, x => _data.FocusEngaged -= x); } /// @@ -21369,9 +19109,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21396,9 +19134,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateChanged += x, x => _data.DateChanged -= x); + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21406,9 +19142,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); } /// @@ -21433,9 +19167,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DatePicked += x, x => _data.DatePicked -= x); + }, x => _data.DatePicked += x, x => _data.DatePicked -= x); } /// @@ -21460,9 +19192,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21487,9 +19217,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21497,9 +19225,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21507,9 +19233,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationFailedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21517,9 +19241,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); } /// @@ -21544,9 +19266,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -21571,9 +19291,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21581,9 +19299,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -21608,9 +19324,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.HubSectionHeaderClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SectionHeaderClick += x, x => _data.SectionHeaderClick -= x); + }, x => _data.SectionHeaderClick += x, x => _data.SectionHeaderClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21618,9 +19332,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SectionsInViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SectionsInViewChanged += x, x => _data.SectionsInViewChanged -= x); + }, x => _data.SectionsInViewChanged += x, x => _data.SectionsInViewChanged -= x); } /// @@ -21645,9 +19357,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21672,9 +19382,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21682,9 +19390,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21692,9 +19398,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21702,9 +19406,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21712,9 +19414,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21722,9 +19422,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21732,9 +19430,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21742,9 +19438,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21752,9 +19446,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21762,9 +19454,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21772,9 +19462,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -21799,9 +19487,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveToolChanged += x, x => _data.ActiveToolChanged -= x); + }, x => _data.ActiveToolChanged += x, x => _data.ActiveToolChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21809,9 +19495,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EraseAllClicked += x, x => _data.EraseAllClicked -= x); + }, x => _data.EraseAllClicked += x, x => _data.EraseAllClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21819,9 +19503,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InkDrawingAttributesChanged += x, x => _data.InkDrawingAttributesChanged -= x); + }, x => _data.InkDrawingAttributesChanged += x, x => _data.InkDrawingAttributesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21829,9 +19511,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsRulerButtonCheckedChanged += x, x => _data.IsRulerButtonCheckedChanged -= x); + }, x => _data.IsRulerButtonCheckedChanged += x, x => _data.IsRulerButtonCheckedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21839,9 +19519,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsStencilButtonCheckedChanged += x, x => _data.IsStencilButtonCheckedChanged -= x); + }, x => _data.IsStencilButtonCheckedChanged += x, x => _data.IsStencilButtonCheckedChanged -= x); } /// @@ -21866,9 +19544,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21893,9 +19569,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Checked += x, x => _data.Checked -= x); + }, x => _data.Checked += x, x => _data.Checked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21903,9 +19577,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Unchecked += x, x => _data.Unchecked -= x); + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); } /// @@ -21930,9 +19602,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21940,9 +19610,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -21967,9 +19635,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -21994,9 +19660,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); } /// @@ -22021,9 +19685,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); } /// @@ -22048,9 +19710,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22075,9 +19735,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22085,9 +19743,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -22112,9 +19768,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemsPicked += x, x => _data.ItemsPicked -= x); + }, x => _data.ItemsPicked += x, x => _data.ItemsPicked -= x); } /// @@ -22139,9 +19793,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ChoosingGroupHeaderContainer += x, x => _data.ChoosingGroupHeaderContainer -= x); + }, x => _data.ChoosingGroupHeaderContainer += x, x => _data.ChoosingGroupHeaderContainer -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22149,9 +19801,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ChoosingItemContainer += x, x => _data.ChoosingItemContainer -= x); + }, x => _data.ChoosingItemContainer += x, x => _data.ChoosingItemContainer -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22159,9 +19809,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainerContentChanging += x, x => _data.ContainerContentChanging -= x); + }, x => _data.ContainerContentChanging += x, x => _data.ContainerContentChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22169,9 +19817,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22179,9 +19825,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.DragItemsStartingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22189,9 +19833,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ItemClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemClick += x, x => _data.ItemClick -= x); + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); } /// @@ -22216,9 +19858,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22226,9 +19866,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22236,9 +19874,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22246,9 +19882,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Media.TimelineMarkerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MarkerReached += x, x => _data.MarkerReached -= x); + }, x => _data.MarkerReached += x, x => _data.MarkerReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22256,9 +19890,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22266,9 +19898,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22276,9 +19906,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22286,9 +19914,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PartialMediaFailureDetected += x, x => _data.PartialMediaFailureDetected -= x); + }, x => _data.PartialMediaFailureDetected += x, x => _data.PartialMediaFailureDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22296,9 +19922,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Media.RateChangedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RateChanged += x, x => _data.RateChanged -= x); + }, x => _data.RateChanged += x, x => _data.RateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22306,9 +19930,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22316,9 +19938,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); } /// @@ -22343,9 +19963,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailRequested += x, x => _data.ThumbnailRequested -= x); + }, x => _data.ThumbnailRequested += x, x => _data.ThumbnailRequested -= x); } /// @@ -22370,9 +19988,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -22397,9 +20013,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22407,9 +20021,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22417,9 +20029,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22427,9 +20037,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22437,9 +20045,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22447,9 +20053,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22457,9 +20061,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22467,9 +20069,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22477,9 +20077,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22487,9 +20085,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22497,9 +20093,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -22524,9 +20118,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22534,9 +20126,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22544,9 +20134,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22554,9 +20142,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22564,9 +20150,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22574,9 +20158,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22584,9 +20166,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22594,9 +20174,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22604,9 +20182,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -22631,9 +20207,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BackRequested += x, x => _data.BackRequested -= x); + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22641,9 +20215,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22651,9 +20223,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22661,9 +20231,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22671,9 +20239,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22681,9 +20247,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22691,9 +20255,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22701,9 +20263,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -22728,9 +20288,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22755,9 +20313,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22765,9 +20321,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22775,9 +20329,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PasswordChanging += x, x => _data.PasswordChanging -= x); + }, x => _data.PasswordChanging += x, x => _data.PasswordChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22785,9 +20337,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paste += x, x => _data.Paste -= x); + }, x => _data.Paste += x, x => _data.Paste -= x); } /// @@ -22812,9 +20362,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22839,9 +20387,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Confirmed += x, x => _data.Confirmed -= x); + }, x => _data.Confirmed += x, x => _data.Confirmed -= x); } /// @@ -22866,9 +20412,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemLoaded += x, x => _data.PivotItemLoaded -= x); + }, x => _data.PivotItemLoaded += x, x => _data.PivotItemLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22876,9 +20420,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemLoading += x, x => _data.PivotItemLoading -= x); + }, x => _data.PivotItemLoading += x, x => _data.PivotItemLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22886,9 +20428,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemUnloaded += x, x => _data.PivotItemUnloaded -= x); + }, x => _data.PivotItemUnloaded += x, x => _data.PivotItemUnloaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22896,9 +20436,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemUnloading += x, x => _data.PivotItemUnloading -= x); + }, x => _data.PivotItemUnloading += x, x => _data.PivotItemUnloading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22906,9 +20444,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -22933,9 +20469,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22943,9 +20477,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -22970,9 +20502,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22980,9 +20510,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22990,9 +20518,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23000,9 +20526,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23010,9 +20534,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23020,9 +20542,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23030,9 +20550,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23040,9 +20558,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -23067,9 +20583,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RatingControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -23094,9 +20608,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23121,9 +20633,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); } /// @@ -23148,9 +20658,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23158,9 +20666,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RefreshStateChanged += x, x => _data.RefreshStateChanged -= x); + }, x => _data.RefreshStateChanged += x, x => _data.RefreshStateChanged -= x); } /// @@ -23185,9 +20691,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23195,9 +20699,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLinkChanged += x, x => _data.ContentLinkChanged -= x); + }, x => _data.ContentLinkChanged += x, x => _data.ContentLinkChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23205,9 +20707,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLinkInvoked += x, x => _data.ContentLinkInvoked -= x); + }, x => _data.ContentLinkInvoked += x, x => _data.ContentLinkInvoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23215,9 +20715,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23225,9 +20723,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23235,9 +20731,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23245,9 +20739,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paste += x, x => _data.Paste -= x); + }, x => _data.Paste += x, x => _data.Paste -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23255,9 +20747,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23265,9 +20755,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23275,9 +20763,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23285,9 +20771,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextChanging += x, x => _data.TextChanging -= x); + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23295,9 +20779,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23305,9 +20787,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23315,9 +20795,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); } /// @@ -23342,9 +20820,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23352,9 +20828,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23362,9 +20836,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -23389,9 +20861,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); } /// @@ -23416,9 +20886,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23443,9 +20911,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23453,9 +20919,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23463,9 +20927,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23473,9 +20935,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23483,9 +20943,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23493,9 +20951,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23503,9 +20959,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23513,9 +20967,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23523,9 +20975,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -23550,9 +21000,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AnchorRequested += x, x => _data.AnchorRequested -= x); + }, x => _data.AnchorRequested += x, x => _data.AnchorRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23560,9 +21008,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DirectManipulationCompleted += x, x => _data.DirectManipulationCompleted -= x); + }, x => _data.DirectManipulationCompleted += x, x => _data.DirectManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23570,9 +21016,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DirectManipulationStarted += x, x => _data.DirectManipulationStarted -= x); + }, x => _data.DirectManipulationStarted += x, x => _data.DirectManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23580,9 +21024,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChanged += x, x => _data.ViewChanged -= x); + }, x => _data.ViewChanged += x, x => _data.ViewChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23590,9 +21032,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChanging += x, x => _data.ViewChanging -= x); + }, x => _data.ViewChanging += x, x => _data.ViewChanging -= x); } /// @@ -23617,9 +21057,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrepareForFocusOnKeyboardInput += x, x => _data.PrepareForFocusOnKeyboardInput -= x); + }, x => _data.PrepareForFocusOnKeyboardInput += x, x => _data.PrepareForFocusOnKeyboardInput -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23627,9 +21065,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QueryChanged += x, x => _data.QueryChanged -= x); + }, x => _data.QueryChanged += x, x => _data.QueryChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23637,9 +21073,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23647,9 +21081,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); + }, x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23657,9 +21089,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); + }, x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); } /// @@ -23684,9 +21114,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChangeCompleted += x, x => _data.ViewChangeCompleted -= x); + }, x => _data.ViewChangeCompleted += x, x => _data.ViewChangeCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23694,9 +21122,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChangeStarted += x, x => _data.ViewChangeStarted -= x); + }, x => _data.ViewChangeStarted += x, x => _data.ViewChangeStarted -= x); } /// @@ -23721,9 +21147,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.BackClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackClick += x, x => _data.BackClick -= x); + }, x => _data.BackClick += x, x => _data.BackClick -= x); } /// @@ -23748,9 +21172,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, int e) => eventHandler(e); return Handler; - } - - , x => _data.IndexClicked += x, x => _data.IndexClicked -= x); + }, x => _data.IndexClicked += x, x => _data.IndexClicked -= x); } /// @@ -23775,9 +21197,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -23802,9 +21222,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23812,9 +21230,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23822,9 +21238,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23832,9 +21246,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); } /// @@ -23859,9 +21271,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23869,9 +21279,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -23896,9 +21304,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompositionScaleChanged += x, x => _data.CompositionScaleChanged -= x); + }, x => _data.CompositionScaleChanged += x, x => _data.CompositionScaleChanged -= x); } /// @@ -23923,9 +21329,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23933,9 +21337,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -23960,9 +21362,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23987,9 +21387,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23997,9 +21395,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24007,9 +21403,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -24034,9 +21428,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BeforeTextChanging += x, x => _data.BeforeTextChanging -= x); + }, x => _data.BeforeTextChanging += x, x => _data.BeforeTextChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24044,9 +21436,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24054,9 +21444,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24064,9 +21452,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24074,9 +21460,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24084,9 +21468,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paste += x, x => _data.Paste -= x); + }, x => _data.Paste += x, x => _data.Paste -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24094,9 +21476,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24104,9 +21484,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24114,9 +21492,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24124,9 +21500,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextChanging += x, x => _data.TextChanging -= x); + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24134,9 +21508,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24144,9 +21516,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24154,9 +21524,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); } /// @@ -24181,9 +21549,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24191,9 +21557,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24201,9 +21565,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24211,9 +21573,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24221,9 +21581,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24231,9 +21589,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24241,9 +21597,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24251,9 +21605,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24261,9 +21613,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -24288,9 +21638,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24315,9 +21663,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedTimeChanged += x, x => _data.SelectedTimeChanged -= x); + }, x => _data.SelectedTimeChanged += x, x => _data.SelectedTimeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24325,9 +21671,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TimeChanged += x, x => _data.TimeChanged -= x); + }, x => _data.TimeChanged += x, x => _data.TimeChanged -= x); } /// @@ -24352,9 +21696,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimePicked += x, x => _data.TimePicked -= x); + }, x => _data.TimePicked += x, x => _data.TimePicked -= x); } /// @@ -24379,9 +21721,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsCheckedChanged += x, x => _data.IsCheckedChanged -= x); + }, x => _data.IsCheckedChanged += x, x => _data.IsCheckedChanged -= x); } /// @@ -24406,9 +21746,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -24433,9 +21771,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24443,9 +21779,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -24470,9 +21804,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Collapsed += x, x => _data.Collapsed -= x); + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24480,9 +21812,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24490,9 +21820,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24500,9 +21828,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Expanding += x, x => _data.Expanding -= x); + }, x => _data.Expanding += x, x => _data.Expanding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24510,9 +21836,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); } /// @@ -24537,9 +21861,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24564,9 +21886,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24591,9 +21911,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24601,9 +21919,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24611,9 +21927,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -24638,9 +21952,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CleanUpVirtualizedItemEvent += x, x => _data.CleanUpVirtualizedItemEvent -= x); + }, x => _data.CleanUpVirtualizedItemEvent += x, x => _data.CleanUpVirtualizedItemEvent -= x); } /// @@ -24665,9 +21977,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24675,9 +21985,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24685,9 +21993,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24695,9 +22001,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24705,9 +22009,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24715,9 +22017,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24725,9 +22025,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24735,9 +22033,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24745,9 +22041,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24755,9 +22049,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24765,9 +22057,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.WebViewNavigationFailedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24775,9 +22065,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24785,9 +22073,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24795,9 +22081,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24805,9 +22089,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.NotifyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24815,9 +22097,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeparateProcessLost += x, x => _data.SeparateProcessLost -= x); + }, x => _data.SeparateProcessLost += x, x => _data.SeparateProcessLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24825,9 +22105,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24835,9 +22113,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24845,9 +22121,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24855,9 +22129,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } } @@ -24964,9 +22236,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); } /// @@ -24991,9 +22261,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UriRequested += x, x => _data.UriRequested -= x); + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); } /// @@ -25018,9 +22286,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UriRequested += x, x => _data.UriRequested -= x); + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); } /// @@ -25045,9 +22311,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25072,9 +22336,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActualCameraChanged += x, x => _data.ActualCameraChanged -= x); + }, x => _data.ActualCameraChanged += x, x => _data.ActualCameraChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25082,9 +22344,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActualCameraChanging += x, x => _data.ActualCameraChanging -= x); + }, x => _data.ActualCameraChanging += x, x => _data.ActualCameraChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25092,9 +22352,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CenterChanged += x, x => _data.CenterChanged -= x); + }, x => _data.CenterChanged += x, x => _data.CenterChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25102,9 +22360,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CustomExperienceChanged += x, x => _data.CustomExperienceChanged -= x); + }, x => _data.CustomExperienceChanged += x, x => _data.CustomExperienceChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25112,9 +22368,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadingChanged += x, x => _data.HeadingChanged -= x); + }, x => _data.HeadingChanged += x, x => _data.HeadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25122,9 +22376,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoadingStatusChanged += x, x => _data.LoadingStatusChanged -= x); + }, x => _data.LoadingStatusChanged += x, x => _data.LoadingStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25132,9 +22384,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25142,9 +22392,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapDoubleTapped += x, x => _data.MapDoubleTapped -= x); + }, x => _data.MapDoubleTapped += x, x => _data.MapDoubleTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25152,9 +22400,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25162,9 +22408,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25172,9 +22416,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25182,9 +22424,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapHolding += x, x => _data.MapHolding -= x); + }, x => _data.MapHolding += x, x => _data.MapHolding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25192,9 +22432,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapRightTapped += x, x => _data.MapRightTapped -= x); + }, x => _data.MapRightTapped += x, x => _data.MapRightTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25202,9 +22440,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapTapped += x, x => _data.MapTapped -= x); + }, x => _data.MapTapped += x, x => _data.MapTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25212,9 +22448,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PitchChanged += x, x => _data.PitchChanged -= x); + }, x => _data.PitchChanged += x, x => _data.PitchChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25222,9 +22456,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25232,9 +22464,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TransformOriginChanged += x, x => _data.TransformOriginChanged -= x); + }, x => _data.TransformOriginChanged += x, x => _data.TransformOriginChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25242,9 +22472,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ZoomLevelChanged += x, x => _data.ZoomLevelChanged -= x); + }, x => _data.ZoomLevelChanged += x, x => _data.ZoomLevelChanged -= x); } /// @@ -25269,9 +22497,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25296,9 +22522,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25323,9 +22547,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25333,9 +22555,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25343,9 +22563,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25353,9 +22571,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); } /// @@ -25380,9 +22596,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25407,9 +22621,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25434,9 +22646,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25461,9 +22671,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25488,9 +22696,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25515,9 +22721,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25525,9 +22729,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); } /// @@ -25552,9 +22754,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25579,9 +22779,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25606,9 +22804,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25633,9 +22829,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -25806,9 +23000,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25833,9 +23025,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25860,9 +23050,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25887,9 +23075,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -25914,9 +23100,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25941,9 +23125,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25951,9 +23133,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -25978,9 +23158,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); } /// @@ -26005,9 +23183,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26032,9 +23208,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26059,9 +23233,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26086,9 +23258,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26096,9 +23266,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26106,9 +23274,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26116,9 +23282,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26126,9 +23290,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opening += x, x => _data.Opening -= x); + }, x => _data.Opening += x, x => _data.Opening -= x); } /// @@ -26153,9 +23315,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26180,9 +23340,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26190,9 +23348,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -26217,9 +23373,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26244,9 +23398,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26271,9 +23423,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26298,9 +23448,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -26325,9 +23473,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26335,9 +23481,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -26362,9 +23506,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26389,9 +23531,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26416,9 +23556,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26426,9 +23564,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -26453,9 +23589,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26463,9 +23597,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -26490,9 +23622,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26500,9 +23630,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -26527,9 +23655,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26554,9 +23680,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26581,9 +23705,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -26608,9 +23730,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scroll += x, x => _data.Scroll -= x); + }, x => _data.Scroll += x, x => _data.Scroll -= x); } /// @@ -26635,9 +23755,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -26662,9 +23780,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26689,9 +23805,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26716,9 +23830,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26726,9 +23838,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragDelta += x, x => _data.DragDelta -= x); + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26736,9 +23846,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); } /// @@ -26763,9 +23871,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Checked += x, x => _data.Checked -= x); + }, x => _data.Checked += x, x => _data.Checked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26773,9 +23879,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26783,9 +23887,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unchecked += x, x => _data.Unchecked -= x); + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); } /// @@ -26810,9 +23912,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26837,9 +23937,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -26890,9 +23988,7 @@ namespace Windows.UI.Xaml.Data { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26917,9 +24013,7 @@ namespace Windows.UI.Xaml.Data { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26944,9 +24038,7 @@ namespace Windows.UI.Xaml.Data { void Handler(object sender, object instance) => eventHandler(instance); return Handler; - } - - , x => _data.ElementInstanceChanged += x, x => _data.ElementInstanceChanged -= x); + }, x => _data.ElementInstanceChanged += x, x => _data.ElementInstanceChanged -= x); } /// @@ -26971,9 +24063,7 @@ namespace Windows.UI.Xaml.Data { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26981,9 +24071,7 @@ namespace Windows.UI.Xaml.Data { void Handler(object sender, global::Windows.UI.Xaml.Data.CurrentChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); } } @@ -27038,9 +24126,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27048,9 +24134,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27058,9 +24142,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); } /// @@ -27085,9 +24167,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27112,9 +24192,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27122,9 +24200,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27132,9 +24208,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); } /// @@ -27159,9 +24233,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27169,9 +24241,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27179,9 +24249,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27189,9 +24257,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27216,9 +24282,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -27269,9 +24333,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27296,9 +24358,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27323,9 +24383,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27333,9 +24391,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -27360,9 +24416,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27370,9 +24424,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CanExecuteRequested += x, x => _data.CanExecuteRequested -= x); + }, x => _data.CanExecuteRequested += x, x => _data.CanExecuteRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27380,9 +24432,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27390,9 +24440,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ExecuteRequested += x, x => _data.ExecuteRequested -= x); + }, x => _data.ExecuteRequested += x, x => _data.ExecuteRequested -= x); } } @@ -27431,9 +24479,7 @@ namespace Windows.UI.Xaml.Interop { void Handler(global::Windows.UI.Xaml.Interop.IBindableObservableVector vector, object e) => eventHandler((vector, e)); return Handler; - } - - , x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); } } @@ -27520,9 +24566,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27547,9 +24591,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27574,9 +24616,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27601,9 +24641,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27628,9 +24666,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27655,9 +24691,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27665,9 +24699,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); } /// @@ -27692,9 +24724,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27719,9 +24749,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); } /// @@ -27746,9 +24774,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27773,9 +24799,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27800,9 +24824,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27827,9 +24849,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27854,9 +24874,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -27931,9 +24949,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -27958,9 +24974,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -27985,9 +24999,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -28012,9 +25024,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -28039,9 +25049,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -28066,9 +25074,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -28093,9 +25099,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -28120,9 +25124,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -28147,9 +25149,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28157,9 +25157,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -28184,9 +25182,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -28229,9 +25225,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(object sender, global::Windows.UI.Xaml.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28239,9 +25233,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28249,9 +25241,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); } /// @@ -28276,9 +25266,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28286,9 +25274,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); } } @@ -28327,9 +25313,7 @@ namespace Windows.UI.Xaml.Media.Media3D { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -28368,9 +25352,7 @@ namespace Windows.UI.Xaml.Navigation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -28409,9 +25391,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(object sender, global::Windows.UI.Xaml.Printing.AddPagesEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AddPages += x, x => _data.AddPages -= x); + }, x => _data.AddPages += x, x => _data.AddPages -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28419,9 +25399,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28429,9 +25407,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(object sender, global::Windows.UI.Xaml.Printing.GetPreviewPageEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GetPreviewPage += x, x => _data.GetPreviewPage -= x); + }, x => _data.GetPreviewPage += x, x => _data.GetPreviewPage -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28439,9 +25415,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(object sender, global::Windows.UI.Xaml.Printing.PaginateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paginate += x, x => _data.Paginate -= x); + }, x => _data.Paginate += x, x => _data.Paginate -= x); } } @@ -28480,9 +25454,7 @@ namespace Windows.Web.Http.Filters { void Handler(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); } } @@ -28521,9 +25493,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28531,9 +25501,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28541,9 +25509,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28551,9 +25517,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28561,9 +25525,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28571,9 +25533,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28581,9 +25541,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28591,9 +25549,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28601,9 +25557,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28611,9 +25565,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28621,9 +25573,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28631,9 +25581,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28641,9 +25589,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28651,9 +25597,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28661,9 +25605,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28671,9 +25613,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28681,9 +25621,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } } @@ -28726,9 +25664,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyPressed += x, x => _data.AcceleratorKeyPressed -= x); + }, x => _data.AcceleratorKeyPressed += x, x => _data.AcceleratorKeyPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28736,9 +25672,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28746,9 +25680,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28756,9 +25688,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28766,9 +25696,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28776,9 +25704,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28786,9 +25712,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28796,9 +25720,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28806,9 +25728,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28816,9 +25736,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28826,9 +25744,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28836,9 +25752,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MoveFocusRequested += x, x => _data.MoveFocusRequested -= x); + }, x => _data.MoveFocusRequested += x, x => _data.MoveFocusRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28846,9 +25760,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28856,9 +25768,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28866,9 +25776,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28876,9 +25784,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28886,9 +25792,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28896,9 +25800,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28906,9 +25808,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28916,9 +25816,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28926,9 +25824,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } /// @@ -28953,9 +25849,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProcessExited += x, x => _data.ProcessExited -= x); + }, x => _data.ProcessExited += x, x => _data.ProcessExited -= x); } } @@ -28973,9 +25867,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.CurrentActivityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Uno.UI.BaseActivity.CurrentChanged += x, x => global::Uno.UI.BaseActivity.CurrentChanged -= x); + }, x => global::Uno.UI.BaseActivity.CurrentChanged += x, x => global::Uno.UI.BaseActivity.CurrentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28983,9 +25875,7 @@ namespace Uno.UI { void Handler(object sender, global::Uno.UI.ActivitiesCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Uno.UI.BaseActivity.InstancesChanged += x, x => global::Uno.UI.BaseActivity.InstancesChanged -= x); + }, x => global::Uno.UI.BaseActivity.InstancesChanged += x, x => global::Uno.UI.BaseActivity.InstancesChanged -= x); } } @@ -29003,9 +25893,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged += x, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged -= x); + }, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged += x, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged -= x); } } @@ -29023,9 +25911,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated += x, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated += x, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29033,9 +25919,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29043,9 +25927,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29053,9 +25935,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29063,9 +25943,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29073,9 +25951,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29083,9 +25959,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected += x, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected += x, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected -= x); } } @@ -29103,9 +25977,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29113,9 +25985,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, global::Windows.ApplicationModel.DataTransfer.ClipboardHistoryChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29123,9 +25993,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29133,9 +26001,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged -= x); } } @@ -29153,9 +26019,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(object sender, global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged += x, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged -= x); + }, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged += x, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged -= x); } } @@ -29173,9 +26037,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded -= x); + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29183,9 +26045,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved -= x); + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29193,9 +26053,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded -= x); + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29203,9 +26061,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved -= x); + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29213,9 +26069,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.Gamepad.GamepadAdded += x, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded -= x); + }, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded += x, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29223,9 +26077,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved += x, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved -= x); + }, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved += x, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29233,9 +26085,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded -= x); + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29243,9 +26093,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved -= x); + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29253,9 +26101,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded -= x); + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29263,9 +26109,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved -= x); + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29273,9 +26117,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded -= x); + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29283,9 +26125,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved -= x); + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved -= x); } } @@ -29303,9 +26143,7 @@ namespace Windows.Gaming.UI { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged += x, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged -= x); + }, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged += x, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29313,9 +26151,7 @@ namespace Windows.Gaming.UI { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.UI.GameBar.VisibilityChanged += x, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged -= x); + }, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged += x, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged -= x); } } @@ -29333,9 +26169,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated -= x); + }, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29343,9 +26177,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29353,9 +26185,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29363,9 +26193,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29373,9 +26201,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29383,9 +26209,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged -= x); } } @@ -29403,9 +26227,7 @@ namespace Windows.Graphics.Holographic { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged += x, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged -= x); + }, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged += x, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged -= x); } } @@ -29423,9 +26245,7 @@ namespace Windows.Media.Core.Preview { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged += x, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged -= x); + }, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged += x, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged -= x); } } @@ -29443,9 +26263,7 @@ namespace Windows.Media.Devices { void Handler(object sender, global::Windows.Media.Devices.DefaultAudioCaptureDeviceChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged -= x); + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29453,9 +26271,7 @@ namespace Windows.Media.Devices { void Handler(object sender, global::Windows.Media.Devices.DefaultAudioRenderDeviceChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged -= x); + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged -= x); } } @@ -29473,9 +26289,7 @@ namespace Windows.Media.Playback { void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground -= x); + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29483,9 +26297,7 @@ namespace Windows.Media.Playback { void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground -= x); + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground -= x); } } @@ -29503,9 +26315,7 @@ namespace Windows.Networking.Connectivity { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged += x, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged -= x); + }, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged += x, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged -= x); } } @@ -29523,9 +26333,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged += x, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged -= x); + }, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged += x, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged -= x); } } @@ -29543,9 +26351,7 @@ namespace Windows.Networking.Proximity { void Handler(object sender, global::Windows.Networking.Proximity.ConnectionRequestedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested += x, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested -= x); + }, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested += x, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29553,9 +26359,7 @@ namespace Windows.Networking.Proximity { void Handler(object sender, global::Windows.Networking.Proximity.TriggeredConnectionStateChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged += x, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged -= x); + }, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged += x, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged -= x); } } @@ -29573,9 +26377,7 @@ namespace Windows.Perception.Spatial { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged += x, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged -= x); + }, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged += x, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged -= x); } } @@ -29593,9 +26395,7 @@ namespace Windows.Phone.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged += x, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged -= x); + }, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged += x, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged -= x); } } @@ -29613,9 +26413,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.BackPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29623,9 +26421,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29633,9 +26429,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29643,9 +26437,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased -= x); } } @@ -29663,9 +26455,7 @@ namespace Windows.Security.Authentication.Identity.Provider { void Handler(object sender, global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged += x, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged -= x); + }, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged += x, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged -= x); } } @@ -29683,9 +26473,7 @@ namespace Windows.System { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased -= x); + }, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29693,9 +26481,7 @@ namespace Windows.System { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased -= x); + }, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29703,9 +26489,7 @@ namespace Windows.System { void Handler(object sender, global::Windows.System.AppMemoryUsageLimitChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging += x, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging -= x); + }, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging += x, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29713,9 +26497,7 @@ namespace Windows.System { void Handler(object sender, global::Windows.System.UserDeviceAssociationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged += x, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged -= x); + }, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged += x, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged -= x); } } @@ -29733,9 +26515,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased -= x); + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29743,9 +26523,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29753,9 +26531,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased -= x); + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29763,9 +26539,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29773,9 +26547,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.BatteryStatusChanged += x, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged -= x); + }, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged += x, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29783,9 +26555,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged += x, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged -= x); + }, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged += x, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29793,9 +26563,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged += x, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged -= x); + }, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged += x, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29803,9 +26571,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged += x, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged -= x); + }, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged += x, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29813,9 +26579,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged += x, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged -= x); + }, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged += x, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged -= x); } } @@ -29833,9 +26597,7 @@ namespace Windows.System.Profile { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged += x, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged -= x); + }, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged += x, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29843,9 +26605,7 @@ namespace Windows.System.Profile { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged += x, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged -= x); + }, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged += x, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29853,9 +26613,7 @@ namespace Windows.System.Profile { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged += x, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged -= x); + }, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged += x, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged -= x); } } @@ -29873,9 +26631,7 @@ namespace Windows.UI.ViewManagement { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged += x, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged -= x); + }, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged += x, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged -= x); } } @@ -29893,9 +26649,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs eventArgs) => eventHandler(eventArgs); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Activated += x, x => global::Windows.UI.WebUI.WebUIApplication.Activated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Activated += x, x => global::Windows.UI.WebUI.WebUIApplication.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29903,9 +26657,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs eventArgs) => eventHandler(eventArgs); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated += x, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated += x, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29913,9 +26665,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.IEnteredBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29923,9 +26673,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.ILeavingBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29933,9 +26681,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.UI.WebUI.IWebUINavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Navigated += x, x => global::Windows.UI.WebUI.WebUIApplication.Navigated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Navigated += x, x => global::Windows.UI.WebUI.WebUIApplication.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29943,9 +26689,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.UI.WebUI.NewWebUIViewCreatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated += x, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated += x, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29953,9 +26697,7 @@ namespace Windows.UI.WebUI { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Resuming += x, x => global::Windows.UI.WebUI.WebUIApplication.Resuming -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Resuming += x, x => global::Windows.UI.WebUI.WebUIApplication.Resuming -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29963,9 +26705,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.ISuspendingEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Suspending += x, x => global::Windows.UI.WebUI.WebUIApplication.Suspending -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Suspending += x, x => global::Windows.UI.WebUI.WebUIApplication.Suspending -= x); } } @@ -29983,9 +26723,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, object args) => eventHandler(args); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged += x, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged -= x); + }, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged += x, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29993,9 +26731,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -30003,9 +26739,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerGotFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -30013,9 +26747,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -30023,9 +26755,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerLostFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus -= x); } } @@ -30043,9 +26773,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, global::Windows.UI.Xaml.Media.RenderedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered -= x); + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -30053,9 +26781,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering -= x); + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -30063,8 +26789,6 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost -= x); + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.xamarinios1010.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.net5.0.approved.txt similarity index 79% rename from src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.xamarinios1010.approved.txt rename to src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.net5.0.approved.txt index 487df91..45eafdd 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.xamarinios1010.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.net5.0.approved.txt @@ -1,4 +1,10 @@ +using global::System; +using global::System.Reactive; +using global::System.Reactive.Linq; +using global::System.Reactive.Subjects; +using global::Pharmacist.Common; + namespace Uno.UI.Common { /// @@ -9,34 +15,32 @@ namespace Uno.UI.Common /// /// A wrapper class which wraps all the events contained within the class. /// - public static DelegateCommandEvents Events(this global::Uno.UI.Common.DelegateCommand item) => new DelegateCommandEvents(item); + public static RxDelegateCommandEvents Events(this global::Uno.UI.Common.DelegateCommand item) => new RxDelegateCommandEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class DelegateCommandEvents + public class RxDelegateCommandEvents { private readonly global::Uno.UI.Common.DelegateCommand _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DelegateCommandEvents(global::Uno.UI.Common.DelegateCommand data) + public RxDelegateCommandEvents(global::Uno.UI.Common.DelegateCommand data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } } @@ -50,34 +54,32 @@ namespace Uno.Xaml /// /// A wrapper class which wraps all the events contained within the class. /// - public static IXamlNameResolverEvents Events(this global::Uno.Xaml.IXamlNameResolver item) => new IXamlNameResolverEvents(item); + public static RxIXamlNameResolverEvents Events(this global::Uno.Xaml.IXamlNameResolver item) => new RxIXamlNameResolverEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class IXamlNameResolverEvents + public class RxIXamlNameResolverEvents { private readonly global::Uno.Xaml.IXamlNameResolver _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IXamlNameResolverEvents(global::Uno.Xaml.IXamlNameResolver data) + public RxIXamlNameResolverEvents(global::Uno.Xaml.IXamlNameResolver data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable OnNameScopeInitializationComplete => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnNameScopeInitializationComplete += x, x => _data.OnNameScopeInitializationComplete -= x); + }, x => _data.OnNameScopeInitializationComplete += x, x => _data.OnNameScopeInitializationComplete -= x); } } @@ -91,84 +93,72 @@ namespace Windows.ApplicationModel /// /// A wrapper class which wraps all the events contained within the class. /// - public static PackageCatalogEvents Events(this global::Windows.ApplicationModel.PackageCatalog item) => new PackageCatalogEvents(item); + public static RxPackageCatalogEvents Events(this global::Windows.ApplicationModel.PackageCatalog item) => new RxPackageCatalogEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class PackageCatalogEvents + public class RxPackageCatalogEvents { private readonly global::Windows.ApplicationModel.PackageCatalog _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PackageCatalogEvents(global::Windows.ApplicationModel.PackageCatalog data) + public RxPackageCatalogEvents(global::Windows.ApplicationModel.PackageCatalog data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args)> PackageContentGroupStaging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageContentGroupStaging += x, x => _data.PackageContentGroupStaging -= x); + }, x => _data.PackageContentGroupStaging += x, x => _data.PackageContentGroupStaging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args)> PackageInstalling => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageInstalling += x, x => _data.PackageInstalling -= x); + }, x => _data.PackageInstalling += x, x => _data.PackageInstalling -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args)> PackageStaging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageStaging += x, x => _data.PackageStaging -= x); + }, x => _data.PackageStaging += x, x => _data.PackageStaging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args)> PackageStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args)> PackageUninstalling => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args)> PackageUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); } } @@ -182,34 +172,32 @@ namespace Windows.ApplicationModel.Activation /// /// A wrapper class which wraps all the events contained within the class. /// - public static SplashScreenEvents Events(this global::Windows.ApplicationModel.Activation.SplashScreen item) => new SplashScreenEvents(item); + public static RxSplashScreenEvents Events(this global::Windows.ApplicationModel.Activation.SplashScreen item) => new RxSplashScreenEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class SplashScreenEvents + public class RxSplashScreenEvents { private readonly global::Windows.ApplicationModel.Activation.SplashScreen _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SplashScreenEvents(global::Windows.ApplicationModel.Activation.SplashScreen data) + public RxSplashScreenEvents(global::Windows.ApplicationModel.Activation.SplashScreen data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Activation.SplashScreen sender, object args)> Dismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Activation.SplashScreen sender, object args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Activation.SplashScreen sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); } } @@ -223,74 +211,64 @@ namespace Windows.ApplicationModel.AppExtensions /// /// A wrapper class which wraps all the events contained within the class. /// - public static AppExtensionCatalogEvents Events(this global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog item) => new AppExtensionCatalogEvents(item); + public static RxAppExtensionCatalogEvents Events(this global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog item) => new RxAppExtensionCatalogEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AppExtensionCatalogEvents + public class RxAppExtensionCatalogEvents { private readonly global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AppExtensionCatalogEvents(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog data) + public RxAppExtensionCatalogEvents(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args)> PackageInstalled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageInstalled += x, x => _data.PackageInstalled -= x); + }, x => _data.PackageInstalled += x, x => _data.PackageInstalled -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args)> PackageStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args)> PackageUninstalling => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args)> PackageUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUpdated += x, x => _data.PackageUpdated -= x); + }, x => _data.PackageUpdated += x, x => _data.PackageUpdated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args)> PackageUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); } } @@ -304,65 +282,61 @@ namespace Windows.ApplicationModel.Appointments /// /// A wrapper class which wraps all the events contained within the class. /// - public static AppointmentCalendarSyncManagerEvents Events(this global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager item) => new AppointmentCalendarSyncManagerEvents(item); + public static RxAppointmentCalendarSyncManagerEvents Events(this global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager item) => new RxAppointmentCalendarSyncManagerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AppointmentStoreEvents Events(this global::Windows.ApplicationModel.Appointments.AppointmentStore item) => new AppointmentStoreEvents(item); + public static RxAppointmentStoreEvents Events(this global::Windows.ApplicationModel.Appointments.AppointmentStore item) => new RxAppointmentStoreEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AppointmentCalendarSyncManagerEvents + public class RxAppointmentCalendarSyncManagerEvents { private readonly global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AppointmentCalendarSyncManagerEvents(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager data) + public RxAppointmentCalendarSyncManagerEvents(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AppointmentStoreEvents + public class RxAppointmentStoreEvents { private readonly global::Windows.ApplicationModel.Appointments.AppointmentStore _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AppointmentStoreEvents(global::Windows.ApplicationModel.Appointments.AppointmentStore data) + public RxAppointmentStoreEvents(global::Windows.ApplicationModel.Appointments.AppointmentStore data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args)> StoreChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); } } @@ -376,84 +350,72 @@ namespace Windows.ApplicationModel.Appointments.DataProvider /// /// A wrapper class which wraps all the events contained within the class. /// - public static AppointmentDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection item) => new AppointmentDataProviderConnectionEvents(item); + public static RxAppointmentDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection item) => new RxAppointmentDataProviderConnectionEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AppointmentDataProviderConnectionEvents + public class RxAppointmentDataProviderConnectionEvents { private readonly global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AppointmentDataProviderConnectionEvents(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection data) + public RxAppointmentDataProviderConnectionEvents(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args)> CancelMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CancelMeetingRequested += x, x => _data.CancelMeetingRequested -= x); + }, x => _data.CancelMeetingRequested += x, x => _data.CancelMeetingRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args)> CreateOrUpdateAppointmentRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateOrUpdateAppointmentRequested += x, x => _data.CreateOrUpdateAppointmentRequested -= x); + }, x => _data.CreateOrUpdateAppointmentRequested += x, x => _data.CreateOrUpdateAppointmentRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args)> ForwardMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args)> ProposeNewTimeForMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args)> SyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args)> UpdateMeetingResponseRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); } } @@ -467,44 +429,40 @@ namespace Windows.ApplicationModel.AppService /// /// A wrapper class which wraps all the events contained within the class. /// - public static AppServiceConnectionEvents Events(this global::Windows.ApplicationModel.AppService.AppServiceConnection item) => new AppServiceConnectionEvents(item); + public static RxAppServiceConnectionEvents Events(this global::Windows.ApplicationModel.AppService.AppServiceConnection item) => new RxAppServiceConnectionEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AppServiceConnectionEvents + public class RxAppServiceConnectionEvents { private readonly global::Windows.ApplicationModel.AppService.AppServiceConnection _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AppServiceConnectionEvents(global::Windows.ApplicationModel.AppService.AppServiceConnection data) + public RxAppServiceConnectionEvents(global::Windows.ApplicationModel.AppService.AppServiceConnection data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args)> RequestReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args)> ServiceClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServiceClosed += x, x => _data.ServiceClosed -= x); + }, x => _data.ServiceClosed += x, x => _data.ServiceClosed -= x); } } @@ -518,147 +476,135 @@ namespace Windows.ApplicationModel.Background /// /// A wrapper class which wraps all the events contained within the class. /// - public static BackgroundTaskRegistrationEvents Events(this global::Windows.ApplicationModel.Background.BackgroundTaskRegistration item) => new BackgroundTaskRegistrationEvents(item); + public static RxBackgroundTaskRegistrationEvents Events(this global::Windows.ApplicationModel.Background.BackgroundTaskRegistration item) => new RxBackgroundTaskRegistrationEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static BackgroundTaskRegistrationGroupEvents Events(this global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup item) => new BackgroundTaskRegistrationGroupEvents(item); + public static RxBackgroundTaskRegistrationGroupEvents Events(this global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup item) => new RxBackgroundTaskRegistrationGroupEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IBackgroundTaskInstanceEvents Events(this global::Windows.ApplicationModel.Background.IBackgroundTaskInstance item) => new IBackgroundTaskInstanceEvents(item); + public static RxIBackgroundTaskInstanceEvents Events(this global::Windows.ApplicationModel.Background.IBackgroundTaskInstance item) => new RxIBackgroundTaskInstanceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IBackgroundTaskRegistrationEvents Events(this global::Windows.ApplicationModel.Background.IBackgroundTaskRegistration item) => new IBackgroundTaskRegistrationEvents(item); + public static RxIBackgroundTaskRegistrationEvents Events(this global::Windows.ApplicationModel.Background.IBackgroundTaskRegistration item) => new RxIBackgroundTaskRegistrationEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class BackgroundTaskRegistrationEvents + public class RxBackgroundTaskRegistrationEvents { private readonly global::Windows.ApplicationModel.Background.BackgroundTaskRegistration _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BackgroundTaskRegistrationEvents(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration data) + public RxBackgroundTaskRegistrationEvents(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args)> Progress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Progress += x, x => _data.Progress -= x); + }, x => _data.Progress += x, x => _data.Progress -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class BackgroundTaskRegistrationGroupEvents + public class RxBackgroundTaskRegistrationGroupEvents { private readonly global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BackgroundTaskRegistrationGroupEvents(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup data) + public RxBackgroundTaskRegistrationGroupEvents(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args)> BackgroundActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BackgroundActivated += x, x => _data.BackgroundActivated -= x); + }, x => _data.BackgroundActivated += x, x => _data.BackgroundActivated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IBackgroundTaskInstanceEvents + public class RxIBackgroundTaskInstanceEvents { private readonly global::Windows.ApplicationModel.Background.IBackgroundTaskInstance _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IBackgroundTaskInstanceEvents(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance data) + public RxIBackgroundTaskInstanceEvents(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason)> Canceled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IBackgroundTaskRegistrationEvents + public class RxIBackgroundTaskRegistrationEvents { private readonly global::Windows.ApplicationModel.Background.IBackgroundTaskRegistration _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IBackgroundTaskRegistrationEvents(global::Windows.ApplicationModel.Background.IBackgroundTaskRegistration data) + public RxIBackgroundTaskRegistrationEvents(global::Windows.ApplicationModel.Background.IBackgroundTaskRegistration data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args)> Progress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Progress += x, x => _data.Progress -= x); + }, x => _data.Progress += x, x => _data.Progress -= x); } } @@ -672,137 +618,127 @@ namespace Windows.ApplicationModel.Chat /// /// A wrapper class which wraps all the events contained within the class. /// - public static ChatConversationEvents Events(this global::Windows.ApplicationModel.Chat.ChatConversation item) => new ChatConversationEvents(item); + public static RxChatConversationEvents Events(this global::Windows.ApplicationModel.Chat.ChatConversation item) => new RxChatConversationEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ChatMessageStoreEvents Events(this global::Windows.ApplicationModel.Chat.ChatMessageStore item) => new ChatMessageStoreEvents(item); + public static RxChatMessageStoreEvents Events(this global::Windows.ApplicationModel.Chat.ChatMessageStore item) => new RxChatMessageStoreEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RcsEndUserMessageManagerEvents Events(this global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager item) => new RcsEndUserMessageManagerEvents(item); + public static RxRcsEndUserMessageManagerEvents Events(this global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager item) => new RxRcsEndUserMessageManagerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RcsTransportEvents Events(this global::Windows.ApplicationModel.Chat.RcsTransport item) => new RcsTransportEvents(item); + public static RxRcsTransportEvents Events(this global::Windows.ApplicationModel.Chat.RcsTransport item) => new RxRcsTransportEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ChatConversationEvents + public class RxChatConversationEvents { private readonly global::Windows.ApplicationModel.Chat.ChatConversation _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ChatConversationEvents(global::Windows.ApplicationModel.Chat.ChatConversation data) + public RxChatConversationEvents(global::Windows.ApplicationModel.Chat.ChatConversation data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args)> RemoteParticipantComposingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteParticipantComposingChanged += x, x => _data.RemoteParticipantComposingChanged -= x); + }, x => _data.RemoteParticipantComposingChanged += x, x => _data.RemoteParticipantComposingChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ChatMessageStoreEvents + public class RxChatMessageStoreEvents { private readonly global::Windows.ApplicationModel.Chat.ChatMessageStore _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ChatMessageStoreEvents(global::Windows.ApplicationModel.Chat.ChatMessageStore data) + public RxChatMessageStoreEvents(global::Windows.ApplicationModel.Chat.ChatMessageStore data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args)> MessageChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageChanged += x, x => _data.MessageChanged -= x); + }, x => _data.MessageChanged += x, x => _data.MessageChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args)> StoreChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RcsEndUserMessageManagerEvents + public class RxRcsEndUserMessageManagerEvents { private readonly global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RcsEndUserMessageManagerEvents(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager data) + public RxRcsEndUserMessageManagerEvents(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args)> MessageAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageAvailableChanged += x, x => _data.MessageAvailableChanged -= x); + }, x => _data.MessageAvailableChanged += x, x => _data.MessageAvailableChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RcsTransportEvents + public class RxRcsTransportEvents { private readonly global::Windows.ApplicationModel.Chat.RcsTransport _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RcsTransportEvents(global::Windows.ApplicationModel.Chat.RcsTransport data) + public RxRcsTransportEvents(global::Windows.ApplicationModel.Chat.RcsTransport data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args)> ServiceKindSupportedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServiceKindSupportedChanged += x, x => _data.ServiceKindSupportedChanged -= x); + }, x => _data.ServiceKindSupportedChanged += x, x => _data.ServiceKindSupportedChanged -= x); } } @@ -816,137 +752,127 @@ namespace Windows.ApplicationModel.Contacts /// /// A wrapper class which wraps all the events contained within the class. /// - public static ContactListEvents Events(this global::Windows.ApplicationModel.Contacts.ContactList item) => new ContactListEvents(item); + public static RxContactListEvents Events(this global::Windows.ApplicationModel.Contacts.ContactList item) => new RxContactListEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ContactListSyncManagerEvents Events(this global::Windows.ApplicationModel.Contacts.ContactListSyncManager item) => new ContactListSyncManagerEvents(item); + public static RxContactListSyncManagerEvents Events(this global::Windows.ApplicationModel.Contacts.ContactListSyncManager item) => new RxContactListSyncManagerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ContactPanelEvents Events(this global::Windows.ApplicationModel.Contacts.ContactPanel item) => new ContactPanelEvents(item); + public static RxContactPanelEvents Events(this global::Windows.ApplicationModel.Contacts.ContactPanel item) => new RxContactPanelEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ContactStoreEvents Events(this global::Windows.ApplicationModel.Contacts.ContactStore item) => new ContactStoreEvents(item); + public static RxContactStoreEvents Events(this global::Windows.ApplicationModel.Contacts.ContactStore item) => new RxContactStoreEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ContactListEvents + public class RxContactListEvents { private readonly global::Windows.ApplicationModel.Contacts.ContactList _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ContactListEvents(global::Windows.ApplicationModel.Contacts.ContactList data) + public RxContactListEvents(global::Windows.ApplicationModel.Contacts.ContactList data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)> ContactChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ContactListSyncManagerEvents + public class RxContactListSyncManagerEvents { private readonly global::Windows.ApplicationModel.Contacts.ContactListSyncManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ContactListSyncManagerEvents(global::Windows.ApplicationModel.Contacts.ContactListSyncManager data) + public RxContactListSyncManagerEvents(global::Windows.ApplicationModel.Contacts.ContactListSyncManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ContactPanelEvents + public class RxContactPanelEvents { private readonly global::Windows.ApplicationModel.Contacts.ContactPanel _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ContactPanelEvents(global::Windows.ApplicationModel.Contacts.ContactPanel data) + public RxContactPanelEvents(global::Windows.ApplicationModel.Contacts.ContactPanel data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args)> LaunchFullAppRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LaunchFullAppRequested += x, x => _data.LaunchFullAppRequested -= x); + }, x => _data.LaunchFullAppRequested += x, x => _data.LaunchFullAppRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ContactStoreEvents + public class RxContactStoreEvents { private readonly global::Windows.ApplicationModel.Contacts.ContactStore _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ContactStoreEvents(global::Windows.ApplicationModel.Contacts.ContactStore data) + public RxContactStoreEvents(global::Windows.ApplicationModel.Contacts.ContactStore data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)> ContactChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); } } @@ -960,64 +886,56 @@ namespace Windows.ApplicationModel.Contacts.DataProvider /// /// A wrapper class which wraps all the events contained within the class. /// - public static ContactDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection item) => new ContactDataProviderConnectionEvents(item); + public static RxContactDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection item) => new RxContactDataProviderConnectionEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ContactDataProviderConnectionEvents + public class RxContactDataProviderConnectionEvents { private readonly global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ContactDataProviderConnectionEvents(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection data) + public RxContactDataProviderConnectionEvents(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args)> CreateOrUpdateContactRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateOrUpdateContactRequested += x, x => _data.CreateOrUpdateContactRequested -= x); + }, x => _data.CreateOrUpdateContactRequested += x, x => _data.CreateOrUpdateContactRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args)> DeleteContactRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeleteContactRequested += x, x => _data.DeleteContactRequested -= x); + }, x => _data.DeleteContactRequested += x, x => _data.DeleteContactRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args)> ServerSearchReadBatchRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args)> SyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); } } @@ -1031,34 +949,32 @@ namespace Windows.ApplicationModel.Contacts.Provider /// /// A wrapper class which wraps all the events contained within the class. /// - public static ContactPickerUIEvents Events(this global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI item) => new ContactPickerUIEvents(item); + public static RxContactPickerUIEvents Events(this global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI item) => new RxContactPickerUIEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ContactPickerUIEvents + public class RxContactPickerUIEvents { private readonly global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ContactPickerUIEvents(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI data) + public RxContactPickerUIEvents(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args)> ContactRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContactRemoved += x, x => _data.ContactRemoved -= x); + }, x => _data.ContactRemoved += x, x => _data.ContactRemoved -= x); } } @@ -1072,116 +988,106 @@ namespace Windows.ApplicationModel.Core /// /// A wrapper class which wraps all the events contained within the class. /// - public static CoreApplicationViewEvents Events(this global::Windows.ApplicationModel.Core.CoreApplicationView item) => new CoreApplicationViewEvents(item); + public static RxCoreApplicationViewEvents Events(this global::Windows.ApplicationModel.Core.CoreApplicationView item) => new RxCoreApplicationViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CoreApplicationViewTitleBarEvents Events(this global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar item) => new CoreApplicationViewTitleBarEvents(item); + public static RxCoreApplicationViewTitleBarEvents Events(this global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar item) => new RxCoreApplicationViewTitleBarEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ICoreApplicationUnhandledErrorEvents Events(this global::Windows.ApplicationModel.Core.ICoreApplicationUnhandledError item) => new ICoreApplicationUnhandledErrorEvents(item); + public static RxICoreApplicationUnhandledErrorEvents Events(this global::Windows.ApplicationModel.Core.ICoreApplicationUnhandledError item) => new RxICoreApplicationUnhandledErrorEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class CoreApplicationViewEvents + public class RxCoreApplicationViewEvents { private readonly global::Windows.ApplicationModel.Core.CoreApplicationView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CoreApplicationViewEvents(global::Windows.ApplicationModel.Core.CoreApplicationView data) + public RxCoreApplicationViewEvents(global::Windows.ApplicationModel.Core.CoreApplicationView data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args)> HostedViewClosing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HostedViewClosing += x, x => _data.HostedViewClosing -= x); + }, x => _data.HostedViewClosing += x, x => _data.HostedViewClosing -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CoreApplicationViewTitleBarEvents + public class RxCoreApplicationViewTitleBarEvents { private readonly global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CoreApplicationViewTitleBarEvents(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar data) + public RxCoreApplicationViewTitleBarEvents(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)> IsVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)> LayoutMetricsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LayoutMetricsChanged += x, x => _data.LayoutMetricsChanged -= x); + }, x => _data.LayoutMetricsChanged += x, x => _data.LayoutMetricsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ICoreApplicationUnhandledErrorEvents + public class RxICoreApplicationUnhandledErrorEvents { private readonly global::Windows.ApplicationModel.Core.ICoreApplicationUnhandledError _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ICoreApplicationUnhandledErrorEvents(global::Windows.ApplicationModel.Core.ICoreApplicationUnhandledError data) + public RxICoreApplicationUnhandledErrorEvents(global::Windows.ApplicationModel.Core.ICoreApplicationUnhandledError data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable UnhandledErrorDetected => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UnhandledErrorDetected += x, x => _data.UnhandledErrorDetected -= x); + }, x => _data.UnhandledErrorDetected += x, x => _data.UnhandledErrorDetected -= x); } } @@ -1195,105 +1101,93 @@ namespace Windows.ApplicationModel.DataTransfer /// /// A wrapper class which wraps all the events contained within the class. /// - public static DataPackageEvents Events(this global::Windows.ApplicationModel.DataTransfer.DataPackage item) => new DataPackageEvents(item); + public static RxDataPackageEvents Events(this global::Windows.ApplicationModel.DataTransfer.DataPackage item) => new RxDataPackageEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DataTransferManagerEvents Events(this global::Windows.ApplicationModel.DataTransfer.DataTransferManager item) => new DataTransferManagerEvents(item); + public static RxDataTransferManagerEvents Events(this global::Windows.ApplicationModel.DataTransfer.DataTransferManager item) => new RxDataTransferManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class DataPackageEvents + public class RxDataPackageEvents { private readonly global::Windows.ApplicationModel.DataTransfer.DataPackage _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DataPackageEvents(global::Windows.ApplicationModel.DataTransfer.DataPackage data) + public RxDataPackageEvents(global::Windows.ApplicationModel.DataTransfer.DataPackage data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args)> Destroyed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args)> OperationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args)> ShareCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShareCompleted += x, x => _data.ShareCompleted -= x); + }, x => _data.ShareCompleted += x, x => _data.ShareCompleted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DataTransferManagerEvents + public class RxDataTransferManagerEvents { private readonly global::Windows.ApplicationModel.DataTransfer.DataTransferManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DataTransferManagerEvents(global::Windows.ApplicationModel.DataTransfer.DataTransferManager data) + public RxDataTransferManagerEvents(global::Windows.ApplicationModel.DataTransfer.DataTransferManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args)> DataRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataRequested += x, x => _data.DataRequested -= x); + }, x => _data.DataRequested += x, x => _data.DataRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args)> ShareProvidersRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShareProvidersRequested += x, x => _data.ShareProvidersRequested -= x); + }, x => _data.ShareProvidersRequested += x, x => _data.ShareProvidersRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args)> TargetApplicationChosen => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetApplicationChosen += x, x => _data.TargetApplicationChosen -= x); + }, x => _data.TargetApplicationChosen += x, x => _data.TargetApplicationChosen -= x); } } @@ -1307,34 +1201,32 @@ namespace Windows.ApplicationModel.DataTransfer.DragDrop.Core /// /// A wrapper class which wraps all the events contained within the class. /// - public static CoreDragDropManagerEvents Events(this global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager item) => new CoreDragDropManagerEvents(item); + public static RxCoreDragDropManagerEvents Events(this global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager item) => new RxCoreDragDropManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class CoreDragDropManagerEvents + public class RxCoreDragDropManagerEvents { private readonly global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CoreDragDropManagerEvents(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager data) + public RxCoreDragDropManagerEvents(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args)> TargetRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetRequested += x, x => _data.TargetRequested -= x); + }, x => _data.TargetRequested += x, x => _data.TargetRequested -= x); } } @@ -1348,65 +1240,61 @@ namespace Windows.ApplicationModel.Email /// /// A wrapper class which wraps all the events contained within the class. /// - public static EmailMailboxEvents Events(this global::Windows.ApplicationModel.Email.EmailMailbox item) => new EmailMailboxEvents(item); + public static RxEmailMailboxEvents Events(this global::Windows.ApplicationModel.Email.EmailMailbox item) => new RxEmailMailboxEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static EmailMailboxSyncManagerEvents Events(this global::Windows.ApplicationModel.Email.EmailMailboxSyncManager item) => new EmailMailboxSyncManagerEvents(item); + public static RxEmailMailboxSyncManagerEvents Events(this global::Windows.ApplicationModel.Email.EmailMailboxSyncManager item) => new RxEmailMailboxSyncManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class EmailMailboxEvents + public class RxEmailMailboxEvents { private readonly global::Windows.ApplicationModel.Email.EmailMailbox _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public EmailMailboxEvents(global::Windows.ApplicationModel.Email.EmailMailbox data) + public RxEmailMailboxEvents(global::Windows.ApplicationModel.Email.EmailMailbox data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args)> MailboxChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MailboxChanged += x, x => _data.MailboxChanged -= x); + }, x => _data.MailboxChanged += x, x => _data.MailboxChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class EmailMailboxSyncManagerEvents + public class RxEmailMailboxSyncManagerEvents { private readonly global::Windows.ApplicationModel.Email.EmailMailboxSyncManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public EmailMailboxSyncManagerEvents(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager data) + public RxEmailMailboxSyncManagerEvents(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } } @@ -1420,174 +1308,144 @@ namespace Windows.ApplicationModel.Email.DataProvider /// /// A wrapper class which wraps all the events contained within the class. /// - public static EmailDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection item) => new EmailDataProviderConnectionEvents(item); + public static RxEmailDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection item) => new RxEmailDataProviderConnectionEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class EmailDataProviderConnectionEvents + public class RxEmailDataProviderConnectionEvents { private readonly global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public EmailDataProviderConnectionEvents(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection data) + public RxEmailDataProviderConnectionEvents(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args)> CreateFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateFolderRequested += x, x => _data.CreateFolderRequested -= x); + }, x => _data.CreateFolderRequested += x, x => _data.CreateFolderRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args)> DeleteFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeleteFolderRequested += x, x => _data.DeleteFolderRequested -= x); + }, x => _data.DeleteFolderRequested += x, x => _data.DeleteFolderRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args)> DownloadAttachmentRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadAttachmentRequested += x, x => _data.DownloadAttachmentRequested -= x); + }, x => _data.DownloadAttachmentRequested += x, x => _data.DownloadAttachmentRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args)> DownloadMessageRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadMessageRequested += x, x => _data.DownloadMessageRequested -= x); + }, x => _data.DownloadMessageRequested += x, x => _data.DownloadMessageRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args)> EmptyFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EmptyFolderRequested += x, x => _data.EmptyFolderRequested -= x); + }, x => _data.EmptyFolderRequested += x, x => _data.EmptyFolderRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args)> ForwardMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args)> GetAutoReplySettingsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GetAutoReplySettingsRequested += x, x => _data.GetAutoReplySettingsRequested -= x); + }, x => _data.GetAutoReplySettingsRequested += x, x => _data.GetAutoReplySettingsRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args)> MailboxSyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MailboxSyncRequested += x, x => _data.MailboxSyncRequested -= x); + }, x => _data.MailboxSyncRequested += x, x => _data.MailboxSyncRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args)> MoveFolderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MoveFolderRequested += x, x => _data.MoveFolderRequested -= x); + }, x => _data.MoveFolderRequested += x, x => _data.MoveFolderRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args)> ProposeNewTimeForMeetingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args)> ResolveRecipientsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResolveRecipientsRequested += x, x => _data.ResolveRecipientsRequested -= x); + }, x => _data.ResolveRecipientsRequested += x, x => _data.ResolveRecipientsRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args)> ServerSearchReadBatchRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args)> SetAutoReplySettingsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetAutoReplySettingsRequested += x, x => _data.SetAutoReplySettingsRequested -= x); + }, x => _data.SetAutoReplySettingsRequested += x, x => _data.SetAutoReplySettingsRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args)> UpdateMeetingResponseRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args)> ValidateCertificatesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValidateCertificatesRequested += x, x => _data.ValidateCertificatesRequested -= x); + }, x => _data.ValidateCertificatesRequested += x, x => _data.ValidateCertificatesRequested -= x); } } @@ -1601,34 +1459,32 @@ namespace Windows.ApplicationModel.ExtendedExecution /// /// A wrapper class which wraps all the events contained within the class. /// - public static ExtendedExecutionSessionEvents Events(this global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionSession item) => new ExtendedExecutionSessionEvents(item); + public static RxExtendedExecutionSessionEvents Events(this global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionSession item) => new RxExtendedExecutionSessionEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ExtendedExecutionSessionEvents + public class RxExtendedExecutionSessionEvents { private readonly global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ExtendedExecutionSessionEvents(global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionSession data) + public RxExtendedExecutionSessionEvents(global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Revoked => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionRevokedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionRevokedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Revoked += x, x => _data.Revoked -= x); + }, x => _data.Revoked += x, x => _data.Revoked -= x); } } @@ -1642,34 +1498,32 @@ namespace Windows.ApplicationModel.ExtendedExecution.Foreground /// /// A wrapper class which wraps all the events contained within the class. /// - public static ExtendedExecutionForegroundSessionEvents Events(this global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundSession item) => new ExtendedExecutionForegroundSessionEvents(item); + public static RxExtendedExecutionForegroundSessionEvents Events(this global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundSession item) => new RxExtendedExecutionForegroundSessionEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ExtendedExecutionForegroundSessionEvents + public class RxExtendedExecutionForegroundSessionEvents { private readonly global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ExtendedExecutionForegroundSessionEvents(global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundSession data) + public RxExtendedExecutionForegroundSessionEvents(global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Revoked => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundRevokedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundRevokedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Revoked += x, x => _data.Revoked -= x); + }, x => _data.Revoked += x, x => _data.Revoked -= x); } } @@ -1683,95 +1537,85 @@ namespace Windows.ApplicationModel.LockScreen /// /// A wrapper class which wraps all the events contained within the class. /// - public static LockApplicationHostEvents Events(this global::Windows.ApplicationModel.LockScreen.LockApplicationHost item) => new LockApplicationHostEvents(item); + public static RxLockApplicationHostEvents Events(this global::Windows.ApplicationModel.LockScreen.LockApplicationHost item) => new RxLockApplicationHostEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static LockScreenInfoEvents Events(this global::Windows.ApplicationModel.LockScreen.LockScreenInfo item) => new LockScreenInfoEvents(item); + public static RxLockScreenInfoEvents Events(this global::Windows.ApplicationModel.LockScreen.LockScreenInfo item) => new RxLockScreenInfoEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class LockApplicationHostEvents + public class RxLockApplicationHostEvents { private readonly global::Windows.ApplicationModel.LockScreen.LockApplicationHost _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public LockApplicationHostEvents(global::Windows.ApplicationModel.LockScreen.LockApplicationHost data) + public RxLockApplicationHostEvents(global::Windows.ApplicationModel.LockScreen.LockApplicationHost data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args)> Unlocking => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Unlocking += x, x => _data.Unlocking -= x); + }, x => _data.Unlocking += x, x => _data.Unlocking -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class LockScreenInfoEvents + public class RxLockScreenInfoEvents { private readonly global::Windows.ApplicationModel.LockScreen.LockScreenInfo _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public LockScreenInfoEvents(global::Windows.ApplicationModel.LockScreen.LockScreenInfo data) + public RxLockScreenInfoEvents(global::Windows.ApplicationModel.LockScreen.LockScreenInfo data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> AlarmIconChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AlarmIconChanged += x, x => _data.AlarmIconChanged -= x); + }, x => _data.AlarmIconChanged += x, x => _data.AlarmIconChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> BadgesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BadgesChanged += x, x => _data.BadgesChanged -= x); + }, x => _data.BadgesChanged += x, x => _data.BadgesChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> DetailTextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DetailTextChanged += x, x => _data.DetailTextChanged -= x); + }, x => _data.DetailTextChanged += x, x => _data.DetailTextChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)> LockScreenImageChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LockScreenImageChanged += x, x => _data.LockScreenImageChanged -= x); + }, x => _data.LockScreenImageChanged += x, x => _data.LockScreenImageChanged -= x); } } @@ -1785,34 +1629,32 @@ namespace Windows.ApplicationModel.Resources.Core /// /// A wrapper class which wraps all the events contained within the class. /// - public static ResourceQualifierObservableMapEvents Events(this global::Windows.ApplicationModel.Resources.Core.ResourceQualifierObservableMap item) => new ResourceQualifierObservableMapEvents(item); + public static RxResourceQualifierObservableMapEvents Events(this global::Windows.ApplicationModel.Resources.Core.ResourceQualifierObservableMap item) => new RxResourceQualifierObservableMapEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ResourceQualifierObservableMapEvents + public class RxResourceQualifierObservableMapEvents { private readonly global::Windows.ApplicationModel.Resources.Core.ResourceQualifierObservableMap _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ResourceQualifierObservableMapEvents(global::Windows.ApplicationModel.Resources.Core.ResourceQualifierObservableMap data) + public RxResourceQualifierObservableMapEvents(global::Windows.ApplicationModel.Resources.Core.ResourceQualifierObservableMap data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } } @@ -1826,34 +1668,32 @@ namespace Windows.ApplicationModel.Store /// /// A wrapper class which wraps all the events contained within the class. /// - public static LicenseInformationEvents Events(this global::Windows.ApplicationModel.Store.LicenseInformation item) => new LicenseInformationEvents(item); + public static RxLicenseInformationEvents Events(this global::Windows.ApplicationModel.Store.LicenseInformation item) => new RxLicenseInformationEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class LicenseInformationEvents + public class RxLicenseInformationEvents { private readonly global::Windows.ApplicationModel.Store.LicenseInformation _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public LicenseInformationEvents(global::Windows.ApplicationModel.Store.LicenseInformation data) + public RxLicenseInformationEvents(global::Windows.ApplicationModel.Store.LicenseInformation data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable LicenseChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler() => eventHandler(global::System.Reactive.Unit.Default); return Handler; - } - - , x => _data.LicenseChanged += x, x => _data.LicenseChanged -= x); + }, x => _data.LicenseChanged += x, x => _data.LicenseChanged -= x); } } @@ -1867,85 +1707,77 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl /// /// A wrapper class which wraps all the events contained within the class. /// - public static AppInstallItemEvents Events(this global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem item) => new AppInstallItemEvents(item); + public static RxAppInstallItemEvents Events(this global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem item) => new RxAppInstallItemEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AppInstallManagerEvents Events(this global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager item) => new AppInstallManagerEvents(item); + public static RxAppInstallManagerEvents Events(this global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager item) => new RxAppInstallManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AppInstallItemEvents + public class RxAppInstallItemEvents { private readonly global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AppInstallItemEvents(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem data) + public RxAppInstallItemEvents(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AppInstallManagerEvents + public class RxAppInstallManagerEvents { private readonly global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AppInstallManagerEvents(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager data) + public RxAppInstallManagerEvents(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)> ItemCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemCompleted += x, x => _data.ItemCompleted -= x); + }, x => _data.ItemCompleted += x, x => _data.ItemCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)> ItemStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemStatusChanged += x, x => _data.ItemStatusChanged -= x); + }, x => _data.ItemStatusChanged += x, x => _data.ItemStatusChanged -= x); } } @@ -1959,34 +1791,32 @@ namespace Windows.ApplicationModel.UserActivities /// /// A wrapper class which wraps all the events contained within the class. /// - public static UserActivityRequestManagerEvents Events(this global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager item) => new UserActivityRequestManagerEvents(item); + public static RxUserActivityRequestManagerEvents Events(this global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager item) => new RxUserActivityRequestManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class UserActivityRequestManagerEvents + public class RxUserActivityRequestManagerEvents { private readonly global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public UserActivityRequestManagerEvents(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager data) + public RxUserActivityRequestManagerEvents(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args)> UserActivityRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserActivityRequested += x, x => _data.UserActivityRequested -= x); + }, x => _data.UserActivityRequested += x, x => _data.UserActivityRequested -= x); } } @@ -2000,34 +1830,32 @@ namespace Windows.ApplicationModel.UserDataAccounts /// /// A wrapper class which wraps all the events contained within the class. /// - public static UserDataAccountStoreEvents Events(this global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore item) => new UserDataAccountStoreEvents(item); + public static RxUserDataAccountStoreEvents Events(this global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore item) => new RxUserDataAccountStoreEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class UserDataAccountStoreEvents + public class RxUserDataAccountStoreEvents { private readonly global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public UserDataAccountStoreEvents(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore data) + public RxUserDataAccountStoreEvents(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args)> StoreChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); } } @@ -2041,34 +1869,32 @@ namespace Windows.ApplicationModel.UserDataTasks /// /// A wrapper class which wraps all the events contained within the class. /// - public static UserDataTaskListSyncManagerEvents Events(this global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager item) => new UserDataTaskListSyncManagerEvents(item); + public static RxUserDataTaskListSyncManagerEvents Events(this global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager item) => new RxUserDataTaskListSyncManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class UserDataTaskListSyncManagerEvents + public class RxUserDataTaskListSyncManagerEvents { private readonly global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public UserDataTaskListSyncManagerEvents(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager data) + public RxUserDataTaskListSyncManagerEvents(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args)> SyncStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } } @@ -2082,74 +1908,64 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider /// /// A wrapper class which wraps all the events contained within the class. /// - public static UserDataTaskDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection item) => new UserDataTaskDataProviderConnectionEvents(item); + public static RxUserDataTaskDataProviderConnectionEvents Events(this global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection item) => new RxUserDataTaskDataProviderConnectionEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class UserDataTaskDataProviderConnectionEvents + public class RxUserDataTaskDataProviderConnectionEvents { private readonly global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public UserDataTaskDataProviderConnectionEvents(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection data) + public RxUserDataTaskDataProviderConnectionEvents(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args)> CompleteTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompleteTaskRequested += x, x => _data.CompleteTaskRequested -= x); + }, x => _data.CompleteTaskRequested += x, x => _data.CompleteTaskRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args)> CreateOrUpdateTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateOrUpdateTaskRequested += x, x => _data.CreateOrUpdateTaskRequested -= x); + }, x => _data.CreateOrUpdateTaskRequested += x, x => _data.CreateOrUpdateTaskRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args)> DeleteTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeleteTaskRequested += x, x => _data.DeleteTaskRequested -= x); + }, x => _data.DeleteTaskRequested += x, x => _data.DeleteTaskRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args)> SkipOccurrenceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SkipOccurrenceRequested += x, x => _data.SkipOccurrenceRequested -= x); + }, x => _data.SkipOccurrenceRequested += x, x => _data.SkipOccurrenceRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args)> SyncRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); } } @@ -2163,34 +1979,32 @@ namespace Windows.ApplicationModel.VoiceCommands /// /// A wrapper class which wraps all the events contained within the class. /// - public static VoiceCommandServiceConnectionEvents Events(this global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection item) => new VoiceCommandServiceConnectionEvents(item); + public static RxVoiceCommandServiceConnectionEvents Events(this global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection item) => new RxVoiceCommandServiceConnectionEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class VoiceCommandServiceConnectionEvents + public class RxVoiceCommandServiceConnectionEvents { private readonly global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public VoiceCommandServiceConnectionEvents(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection data) + public RxVoiceCommandServiceConnectionEvents(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args)> VoiceCommandCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VoiceCommandCompleted += x, x => _data.VoiceCommandCompleted -= x); + }, x => _data.VoiceCommandCompleted += x, x => _data.VoiceCommandCompleted -= x); } } @@ -2204,34 +2018,32 @@ namespace Windows.ApplicationModel.Wallet.System /// /// A wrapper class which wraps all the events contained within the class. /// - public static WalletItemSystemStoreEvents Events(this global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore item) => new WalletItemSystemStoreEvents(item); + public static RxWalletItemSystemStoreEvents Events(this global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore item) => new RxWalletItemSystemStoreEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class WalletItemSystemStoreEvents + public class RxWalletItemSystemStoreEvents { private readonly global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WalletItemSystemStoreEvents(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore data) + public RxWalletItemSystemStoreEvents(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args)> ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args)>(eventHandler => { void Handler(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); } } @@ -2245,166 +2057,146 @@ namespace Windows.Devices.AllJoyn /// /// A wrapper class which wraps all the events contained within the class. /// - public static AllJoynBusAttachmentEvents Events(this global::Windows.Devices.AllJoyn.AllJoynBusAttachment item) => new AllJoynBusAttachmentEvents(item); + public static RxAllJoynBusAttachmentEvents Events(this global::Windows.Devices.AllJoyn.AllJoynBusAttachment item) => new RxAllJoynBusAttachmentEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AllJoynBusObjectEvents Events(this global::Windows.Devices.AllJoyn.AllJoynBusObject item) => new AllJoynBusObjectEvents(item); + public static RxAllJoynBusObjectEvents Events(this global::Windows.Devices.AllJoyn.AllJoynBusObject item) => new RxAllJoynBusObjectEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AllJoynSessionEvents Events(this global::Windows.Devices.AllJoyn.AllJoynSession item) => new AllJoynSessionEvents(item); + public static RxAllJoynSessionEvents Events(this global::Windows.Devices.AllJoyn.AllJoynSession item) => new RxAllJoynSessionEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AllJoynBusAttachmentEvents + public class RxAllJoynBusAttachmentEvents { private readonly global::Windows.Devices.AllJoyn.AllJoynBusAttachment _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AllJoynBusAttachmentEvents(global::Windows.Devices.AllJoyn.AllJoynBusAttachment data) + public RxAllJoynBusAttachmentEvents(global::Windows.Devices.AllJoyn.AllJoynBusAttachment data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args)> AcceptSessionJoinerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceptSessionJoinerRequested += x, x => _data.AcceptSessionJoinerRequested -= x); + }, x => _data.AcceptSessionJoinerRequested += x, x => _data.AcceptSessionJoinerRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args)> AuthenticationComplete => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AuthenticationComplete += x, x => _data.AuthenticationComplete -= x); + }, x => _data.AuthenticationComplete += x, x => _data.AuthenticationComplete -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args)> CredentialsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CredentialsRequested += x, x => _data.CredentialsRequested -= x); + }, x => _data.CredentialsRequested += x, x => _data.CredentialsRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args)> CredentialsVerificationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CredentialsVerificationRequested += x, x => _data.CredentialsVerificationRequested -= x); + }, x => _data.CredentialsVerificationRequested += x, x => _data.CredentialsVerificationRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args)> SessionJoined => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionJoined += x, x => _data.SessionJoined -= x); + }, x => _data.SessionJoined += x, x => _data.SessionJoined -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AllJoynBusObjectEvents + public class RxAllJoynBusObjectEvents { private readonly global::Windows.Devices.AllJoyn.AllJoynBusObject _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AllJoynBusObjectEvents(global::Windows.Devices.AllJoyn.AllJoynBusObject data) + public RxAllJoynBusObjectEvents(global::Windows.Devices.AllJoyn.AllJoynBusObject data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AllJoynSessionEvents + public class RxAllJoynSessionEvents { private readonly global::Windows.Devices.AllJoyn.AllJoynSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AllJoynSessionEvents(global::Windows.Devices.AllJoyn.AllJoynSession data) + public RxAllJoynSessionEvents(global::Windows.Devices.AllJoyn.AllJoynSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args)> Lost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Lost += x, x => _data.Lost -= x); + }, x => _data.Lost += x, x => _data.Lost -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args)> MemberAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MemberAdded += x, x => _data.MemberAdded -= x); + }, x => _data.MemberAdded += x, x => _data.MemberAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args)> MemberRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MemberRemoved += x, x => _data.MemberRemoved -= x); + }, x => _data.MemberRemoved += x, x => _data.MemberRemoved -= x); } } @@ -2418,105 +2210,93 @@ namespace Windows.Devices.Bluetooth /// /// A wrapper class which wraps all the events contained within the class. /// - public static BluetoothDeviceEvents Events(this global::Windows.Devices.Bluetooth.BluetoothDevice item) => new BluetoothDeviceEvents(item); + public static RxBluetoothDeviceEvents Events(this global::Windows.Devices.Bluetooth.BluetoothDevice item) => new RxBluetoothDeviceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static BluetoothLEDeviceEvents Events(this global::Windows.Devices.Bluetooth.BluetoothLEDevice item) => new BluetoothLEDeviceEvents(item); + public static RxBluetoothLEDeviceEvents Events(this global::Windows.Devices.Bluetooth.BluetoothLEDevice item) => new RxBluetoothLEDeviceEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class BluetoothDeviceEvents + public class RxBluetoothDeviceEvents { private readonly global::Windows.Devices.Bluetooth.BluetoothDevice _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BluetoothDeviceEvents(global::Windows.Devices.Bluetooth.BluetoothDevice data) + public RxBluetoothDeviceEvents(global::Windows.Devices.Bluetooth.BluetoothDevice data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)> ConnectionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)> NameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NameChanged += x, x => _data.NameChanged -= x); + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)> SdpRecordsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SdpRecordsChanged += x, x => _data.SdpRecordsChanged -= x); + }, x => _data.SdpRecordsChanged += x, x => _data.SdpRecordsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class BluetoothLEDeviceEvents + public class RxBluetoothLEDeviceEvents { private readonly global::Windows.Devices.Bluetooth.BluetoothLEDevice _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BluetoothLEDeviceEvents(global::Windows.Devices.Bluetooth.BluetoothLEDevice data) + public RxBluetoothLEDeviceEvents(global::Windows.Devices.Bluetooth.BluetoothLEDevice data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)> ConnectionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)> GattServicesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GattServicesChanged += x, x => _data.GattServicesChanged -= x); + }, x => _data.GattServicesChanged += x, x => _data.GattServicesChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)> NameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NameChanged += x, x => _data.NameChanged -= x); + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); } } @@ -2530,75 +2310,69 @@ namespace Windows.Devices.Bluetooth.Advertisement /// /// A wrapper class which wraps all the events contained within the class. /// - public static BluetoothLEAdvertisementPublisherEvents Events(this global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher item) => new BluetoothLEAdvertisementPublisherEvents(item); + public static RxBluetoothLEAdvertisementPublisherEvents Events(this global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher item) => new RxBluetoothLEAdvertisementPublisherEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static BluetoothLEAdvertisementWatcherEvents Events(this global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher item) => new BluetoothLEAdvertisementWatcherEvents(item); + public static RxBluetoothLEAdvertisementWatcherEvents Events(this global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher item) => new RxBluetoothLEAdvertisementWatcherEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class BluetoothLEAdvertisementPublisherEvents + public class RxBluetoothLEAdvertisementPublisherEvents { private readonly global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BluetoothLEAdvertisementPublisherEvents(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher data) + public RxBluetoothLEAdvertisementPublisherEvents(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class BluetoothLEAdvertisementWatcherEvents + public class RxBluetoothLEAdvertisementWatcherEvents { private readonly global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BluetoothLEAdvertisementWatcherEvents(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher data) + public RxBluetoothLEAdvertisementWatcherEvents(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args)> Received => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Received += x, x => _data.Received -= x); + }, x => _data.Received += x, x => _data.Received -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -2612,291 +2386,267 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile /// /// A wrapper class which wraps all the events contained within the class. /// - public static GattCharacteristicEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic item) => new GattCharacteristicEvents(item); + public static RxGattCharacteristicEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic item) => new RxGattCharacteristicEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GattLocalCharacteristicEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic item) => new GattLocalCharacteristicEvents(item); + public static RxGattLocalCharacteristicEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic item) => new RxGattLocalCharacteristicEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GattLocalDescriptorEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor item) => new GattLocalDescriptorEvents(item); + public static RxGattLocalDescriptorEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor item) => new RxGattLocalDescriptorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GattReadRequestEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest item) => new GattReadRequestEvents(item); + public static RxGattReadRequestEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest item) => new RxGattReadRequestEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GattServiceProviderEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider item) => new GattServiceProviderEvents(item); + public static RxGattServiceProviderEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider item) => new RxGattServiceProviderEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GattSessionEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession item) => new GattSessionEvents(item); + public static RxGattSessionEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession item) => new RxGattSessionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GattSubscribedClientEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient item) => new GattSubscribedClientEvents(item); + public static RxGattSubscribedClientEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient item) => new RxGattSubscribedClientEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GattWriteRequestEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest item) => new GattWriteRequestEvents(item); + public static RxGattWriteRequestEvents Events(this global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest item) => new RxGattWriteRequestEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class GattCharacteristicEvents + public class RxGattCharacteristicEvents { private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GattCharacteristicEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic data) + public RxGattCharacteristicEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args)> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GattLocalCharacteristicEvents + public class RxGattLocalCharacteristicEvents { private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GattLocalCharacteristicEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic data) + public RxGattLocalCharacteristicEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)> ReadRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args)> SubscribedClientsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SubscribedClientsChanged += x, x => _data.SubscribedClientsChanged -= x); + }, x => _data.SubscribedClientsChanged += x, x => _data.SubscribedClientsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)> WriteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GattLocalDescriptorEvents + public class RxGattLocalDescriptorEvents { private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GattLocalDescriptorEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor data) + public RxGattLocalDescriptorEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)> ReadRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)> WriteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GattReadRequestEvents + public class RxGattReadRequestEvents { private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GattReadRequestEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest data) + public RxGattReadRequestEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GattServiceProviderEvents + public class RxGattServiceProviderEvents { private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GattServiceProviderEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider data) + public RxGattServiceProviderEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args)> AdvertisementStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GattSessionEvents + public class RxGattSessionEvents { private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GattSessionEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession data) + public RxGattSessionEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args)> MaxPduSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MaxPduSizeChanged += x, x => _data.MaxPduSizeChanged -= x); + }, x => _data.MaxPduSizeChanged += x, x => _data.MaxPduSizeChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args)> SessionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GattSubscribedClientEvents + public class RxGattSubscribedClientEvents { private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GattSubscribedClientEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient data) + public RxGattSubscribedClientEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args)> MaxNotificationSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MaxNotificationSizeChanged += x, x => _data.MaxNotificationSizeChanged -= x); + }, x => _data.MaxNotificationSizeChanged += x, x => _data.MaxNotificationSizeChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GattWriteRequestEvents + public class RxGattWriteRequestEvents { private readonly global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GattWriteRequestEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest data) + public RxGattWriteRequestEvents(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -2910,64 +2660,56 @@ namespace Windows.Devices.Display.Core /// /// A wrapper class which wraps all the events contained within the class. /// - public static DisplayManagerEvents Events(this global::Windows.Devices.Display.Core.DisplayManager item) => new DisplayManagerEvents(item); + public static RxDisplayManagerEvents Events(this global::Windows.Devices.Display.Core.DisplayManager item) => new RxDisplayManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class DisplayManagerEvents + public class RxDisplayManagerEvents { private readonly global::Windows.Devices.Display.Core.DisplayManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DisplayManagerEvents(global::Windows.Devices.Display.Core.DisplayManager data) + public RxDisplayManagerEvents(global::Windows.Devices.Display.Core.DisplayManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args)> Disabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Disabled += x, x => _data.Disabled -= x); + }, x => _data.Disabled += x, x => _data.Disabled -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args)> Enabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Enabled += x, x => _data.Enabled -= x); + }, x => _data.Enabled += x, x => _data.Enabled -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args)> PathsFailedOrInvalidated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PathsFailedOrInvalidated += x, x => _data.PathsFailedOrInvalidated -= x); + }, x => _data.PathsFailedOrInvalidated += x, x => _data.PathsFailedOrInvalidated -= x); } } @@ -2981,187 +2723,167 @@ namespace Windows.Devices.Enumeration /// /// A wrapper class which wraps all the events contained within the class. /// - public static DeviceAccessInformationEvents Events(this global::Windows.Devices.Enumeration.DeviceAccessInformation item) => new DeviceAccessInformationEvents(item); + public static RxDeviceAccessInformationEvents Events(this global::Windows.Devices.Enumeration.DeviceAccessInformation item) => new RxDeviceAccessInformationEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DeviceInformationCustomPairingEvents Events(this global::Windows.Devices.Enumeration.DeviceInformationCustomPairing item) => new DeviceInformationCustomPairingEvents(item); + public static RxDeviceInformationCustomPairingEvents Events(this global::Windows.Devices.Enumeration.DeviceInformationCustomPairing item) => new RxDeviceInformationCustomPairingEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DevicePickerEvents Events(this global::Windows.Devices.Enumeration.DevicePicker item) => new DevicePickerEvents(item); + public static RxDevicePickerEvents Events(this global::Windows.Devices.Enumeration.DevicePicker item) => new RxDevicePickerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DeviceWatcherEvents Events(this global::Windows.Devices.Enumeration.DeviceWatcher item) => new DeviceWatcherEvents(item); + public static RxDeviceWatcherEvents Events(this global::Windows.Devices.Enumeration.DeviceWatcher item) => new RxDeviceWatcherEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class DeviceAccessInformationEvents + public class RxDeviceAccessInformationEvents { private readonly global::Windows.Devices.Enumeration.DeviceAccessInformation _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DeviceAccessInformationEvents(global::Windows.Devices.Enumeration.DeviceAccessInformation data) + public RxDeviceAccessInformationEvents(global::Windows.Devices.Enumeration.DeviceAccessInformation data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args)> AccessChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessChanged += x, x => _data.AccessChanged -= x); + }, x => _data.AccessChanged += x, x => _data.AccessChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DeviceInformationCustomPairingEvents + public class RxDeviceInformationCustomPairingEvents { private readonly global::Windows.Devices.Enumeration.DeviceInformationCustomPairing _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DeviceInformationCustomPairingEvents(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing data) + public RxDeviceInformationCustomPairingEvents(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args)> PairingRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PairingRequested += x, x => _data.PairingRequested -= x); + }, x => _data.PairingRequested += x, x => _data.PairingRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DevicePickerEvents + public class RxDevicePickerEvents { private readonly global::Windows.Devices.Enumeration.DevicePicker _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DevicePickerEvents(global::Windows.Devices.Enumeration.DevicePicker data) + public RxDevicePickerEvents(global::Windows.Devices.Enumeration.DevicePicker data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Enumeration.DevicePicker sender, object args)> DevicePickerDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DevicePicker sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DevicePickerDismissed += x, x => _data.DevicePickerDismissed -= x); + }, x => _data.DevicePickerDismissed += x, x => _data.DevicePickerDismissed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args)> DeviceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeviceSelected += x, x => _data.DeviceSelected -= x); + }, x => _data.DeviceSelected += x, x => _data.DeviceSelected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args)> DisconnectButtonClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DeviceWatcherEvents + public class RxDeviceWatcherEvents { private readonly global::Windows.Devices.Enumeration.DeviceWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DeviceWatcherEvents(global::Windows.Devices.Enumeration.DeviceWatcher data) + public RxDeviceWatcherEvents(global::Windows.Devices.Enumeration.DeviceWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args)>(eventHandler => { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)>(eventHandler => { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args)>(eventHandler => { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -3175,74 +2897,64 @@ namespace Windows.Devices.Enumeration.Pnp /// /// A wrapper class which wraps all the events contained within the class. /// - public static PnpObjectWatcherEvents Events(this global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher item) => new PnpObjectWatcherEvents(item); + public static RxPnpObjectWatcherEvents Events(this global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher item) => new RxPnpObjectWatcherEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class PnpObjectWatcherEvents + public class RxPnpObjectWatcherEvents { private readonly global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PnpObjectWatcherEvents(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher data) + public RxPnpObjectWatcherEvents(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args)>(eventHandler => { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)>(eventHandler => { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args)>(eventHandler => { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -3256,75 +2968,69 @@ namespace Windows.Devices.Geolocation /// /// A wrapper class which wraps all the events contained within the class. /// - public static GeolocatorEvents Events(this global::Windows.Devices.Geolocation.Geolocator item) => new GeolocatorEvents(item); + public static RxGeolocatorEvents Events(this global::Windows.Devices.Geolocation.Geolocator item) => new RxGeolocatorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GeovisitMonitorEvents Events(this global::Windows.Devices.Geolocation.GeovisitMonitor item) => new GeovisitMonitorEvents(item); + public static RxGeovisitMonitorEvents Events(this global::Windows.Devices.Geolocation.GeovisitMonitor item) => new RxGeovisitMonitorEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class GeolocatorEvents + public class RxGeolocatorEvents { private readonly global::Windows.Devices.Geolocation.Geolocator _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GeolocatorEvents(global::Windows.Devices.Geolocation.Geolocator data) + public RxGeolocatorEvents(global::Windows.Devices.Geolocation.Geolocator data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args)> PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GeovisitMonitorEvents + public class RxGeovisitMonitorEvents { private readonly global::Windows.Devices.Geolocation.GeovisitMonitor _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GeovisitMonitorEvents(global::Windows.Devices.Geolocation.GeovisitMonitor data) + public RxGeovisitMonitorEvents(global::Windows.Devices.Geolocation.GeovisitMonitor data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args)> VisitStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisitStateChanged += x, x => _data.VisitStateChanged -= x); + }, x => _data.VisitStateChanged += x, x => _data.VisitStateChanged -= x); } } @@ -3338,44 +3044,40 @@ namespace Windows.Devices.Geolocation.Geofencing /// /// A wrapper class which wraps all the events contained within the class. /// - public static GeofenceMonitorEvents Events(this global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor item) => new GeofenceMonitorEvents(item); + public static RxGeofenceMonitorEvents Events(this global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor item) => new RxGeofenceMonitorEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class GeofenceMonitorEvents + public class RxGeofenceMonitorEvents { private readonly global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GeofenceMonitorEvents(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor data) + public RxGeofenceMonitorEvents(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)> GeofenceStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GeofenceStateChanged += x, x => _data.GeofenceStateChanged -= x); + }, x => _data.GeofenceStateChanged += x, x => _data.GeofenceStateChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } } @@ -3389,34 +3091,32 @@ namespace Windows.Devices.HumanInterfaceDevice /// /// A wrapper class which wraps all the events contained within the class. /// - public static HidDeviceEvents Events(this global::Windows.Devices.HumanInterfaceDevice.HidDevice item) => new HidDeviceEvents(item); + public static RxHidDeviceEvents Events(this global::Windows.Devices.HumanInterfaceDevice.HidDevice item) => new RxHidDeviceEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class HidDeviceEvents + public class RxHidDeviceEvents { private readonly global::Windows.Devices.HumanInterfaceDevice.HidDevice _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public HidDeviceEvents(global::Windows.Devices.HumanInterfaceDevice.HidDevice data) + public RxHidDeviceEvents(global::Windows.Devices.HumanInterfaceDevice.HidDevice data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args)> InputReportReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputReportReceived += x, x => _data.InputReportReceived -= x); + }, x => _data.InputReportReceived += x, x => _data.InputReportReceived -= x); } } @@ -3430,34 +3130,32 @@ namespace Windows.Devices.Input /// /// A wrapper class which wraps all the events contained within the class. /// - public static MouseDeviceEvents Events(this global::Windows.Devices.Input.MouseDevice item) => new MouseDeviceEvents(item); + public static RxMouseDeviceEvents Events(this global::Windows.Devices.Input.MouseDevice item) => new RxMouseDeviceEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class MouseDeviceEvents + public class RxMouseDeviceEvents { private readonly global::Windows.Devices.Input.MouseDevice _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MouseDeviceEvents(global::Windows.Devices.Input.MouseDevice data) + public RxMouseDeviceEvents(global::Windows.Devices.Input.MouseDevice data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args)> MouseMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MouseMoved += x, x => _data.MouseMoved -= x); + }, x => _data.MouseMoved += x, x => _data.MouseMoved -= x); } } @@ -3471,115 +3169,101 @@ namespace Windows.Devices.Input.Preview /// /// A wrapper class which wraps all the events contained within the class. /// - public static GazeDeviceWatcherPreviewEvents Events(this global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview item) => new GazeDeviceWatcherPreviewEvents(item); + public static RxGazeDeviceWatcherPreviewEvents Events(this global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview item) => new RxGazeDeviceWatcherPreviewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GazeInputSourcePreviewEvents Events(this global::Windows.Devices.Input.Preview.GazeInputSourcePreview item) => new GazeInputSourcePreviewEvents(item); + public static RxGazeInputSourcePreviewEvents Events(this global::Windows.Devices.Input.Preview.GazeInputSourcePreview item) => new RxGazeInputSourcePreviewEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class GazeDeviceWatcherPreviewEvents + public class RxGazeDeviceWatcherPreviewEvents { private readonly global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GazeDeviceWatcherPreviewEvents(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview data) + public RxGazeDeviceWatcherPreviewEvents(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GazeInputSourcePreviewEvents + public class RxGazeInputSourcePreviewEvents { private readonly global::Windows.Devices.Input.Preview.GazeInputSourcePreview _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GazeInputSourcePreviewEvents(global::Windows.Devices.Input.Preview.GazeInputSourcePreview data) + public RxGazeInputSourcePreviewEvents(global::Windows.Devices.Input.Preview.GazeInputSourcePreview data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args)> GazeEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GazeEntered += x, x => _data.GazeEntered -= x); + }, x => _data.GazeEntered += x, x => _data.GazeEntered -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args)> GazeExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GazeExited += x, x => _data.GazeExited -= x); + }, x => _data.GazeExited += x, x => _data.GazeExited -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args)> GazeMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GazeMoved += x, x => _data.GazeMoved -= x); + }, x => _data.GazeMoved += x, x => _data.GazeMoved -= x); } } @@ -3593,34 +3277,32 @@ namespace Windows.Devices.Lights /// /// A wrapper class which wraps all the events contained within the class. /// - public static LampEvents Events(this global::Windows.Devices.Lights.Lamp item) => new LampEvents(item); + public static RxLampEvents Events(this global::Windows.Devices.Lights.Lamp item) => new RxLampEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class LampEvents + public class RxLampEvents { private readonly global::Windows.Devices.Lights.Lamp _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public LampEvents(global::Windows.Devices.Lights.Lamp data) + public RxLampEvents(global::Windows.Devices.Lights.Lamp data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args)> AvailabilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); + }, x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); } } @@ -3634,65 +3316,61 @@ namespace Windows.Devices.Lights.Effects /// /// A wrapper class which wraps all the events contained within the class. /// - public static LampArrayBitmapEffectEvents Events(this global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect item) => new LampArrayBitmapEffectEvents(item); + public static RxLampArrayBitmapEffectEvents Events(this global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect item) => new RxLampArrayBitmapEffectEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static LampArrayCustomEffectEvents Events(this global::Windows.Devices.Lights.Effects.LampArrayCustomEffect item) => new LampArrayCustomEffectEvents(item); + public static RxLampArrayCustomEffectEvents Events(this global::Windows.Devices.Lights.Effects.LampArrayCustomEffect item) => new RxLampArrayCustomEffectEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class LampArrayBitmapEffectEvents + public class RxLampArrayBitmapEffectEvents { private readonly global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public LampArrayBitmapEffectEvents(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect data) + public RxLampArrayBitmapEffectEvents(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args)> BitmapRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class LampArrayCustomEffectEvents + public class RxLampArrayCustomEffectEvents { private readonly global::Windows.Devices.Lights.Effects.LampArrayCustomEffect _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public LampArrayCustomEffectEvents(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect data) + public RxLampArrayCustomEffectEvents(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args)> UpdateRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateRequested += x, x => _data.UpdateRequested -= x); + }, x => _data.UpdateRequested += x, x => _data.UpdateRequested -= x); } } @@ -3706,34 +3384,32 @@ namespace Windows.Devices.Midi /// /// A wrapper class which wraps all the events contained within the class. /// - public static MidiInPortEvents Events(this global::Windows.Devices.Midi.MidiInPort item) => new MidiInPortEvents(item); + public static RxMidiInPortEvents Events(this global::Windows.Devices.Midi.MidiInPort item) => new RxMidiInPortEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class MidiInPortEvents + public class RxMidiInPortEvents { private readonly global::Windows.Devices.Midi.MidiInPort _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MidiInPortEvents(global::Windows.Devices.Midi.MidiInPort data) + public RxMidiInPortEvents(global::Windows.Devices.Midi.MidiInPort data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } } @@ -3747,523 +3423,461 @@ namespace Windows.Devices.Perception /// /// A wrapper class which wraps all the events contained within the class. /// - public static PerceptionColorFrameReaderEvents Events(this global::Windows.Devices.Perception.PerceptionColorFrameReader item) => new PerceptionColorFrameReaderEvents(item); + public static RxPerceptionColorFrameReaderEvents Events(this global::Windows.Devices.Perception.PerceptionColorFrameReader item) => new RxPerceptionColorFrameReaderEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PerceptionColorFrameSourceEvents Events(this global::Windows.Devices.Perception.PerceptionColorFrameSource item) => new PerceptionColorFrameSourceEvents(item); + public static RxPerceptionColorFrameSourceEvents Events(this global::Windows.Devices.Perception.PerceptionColorFrameSource item) => new RxPerceptionColorFrameSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PerceptionColorFrameSourceWatcherEvents Events(this global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher item) => new PerceptionColorFrameSourceWatcherEvents(item); + public static RxPerceptionColorFrameSourceWatcherEvents Events(this global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher item) => new RxPerceptionColorFrameSourceWatcherEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PerceptionControlSessionEvents Events(this global::Windows.Devices.Perception.PerceptionControlSession item) => new PerceptionControlSessionEvents(item); + public static RxPerceptionControlSessionEvents Events(this global::Windows.Devices.Perception.PerceptionControlSession item) => new RxPerceptionControlSessionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PerceptionDepthFrameReaderEvents Events(this global::Windows.Devices.Perception.PerceptionDepthFrameReader item) => new PerceptionDepthFrameReaderEvents(item); + public static RxPerceptionDepthFrameReaderEvents Events(this global::Windows.Devices.Perception.PerceptionDepthFrameReader item) => new RxPerceptionDepthFrameReaderEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PerceptionDepthFrameSourceEvents Events(this global::Windows.Devices.Perception.PerceptionDepthFrameSource item) => new PerceptionDepthFrameSourceEvents(item); + public static RxPerceptionDepthFrameSourceEvents Events(this global::Windows.Devices.Perception.PerceptionDepthFrameSource item) => new RxPerceptionDepthFrameSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PerceptionDepthFrameSourceWatcherEvents Events(this global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher item) => new PerceptionDepthFrameSourceWatcherEvents(item); + public static RxPerceptionDepthFrameSourceWatcherEvents Events(this global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher item) => new RxPerceptionDepthFrameSourceWatcherEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PerceptionInfraredFrameReaderEvents Events(this global::Windows.Devices.Perception.PerceptionInfraredFrameReader item) => new PerceptionInfraredFrameReaderEvents(item); + public static RxPerceptionInfraredFrameReaderEvents Events(this global::Windows.Devices.Perception.PerceptionInfraredFrameReader item) => new RxPerceptionInfraredFrameReaderEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PerceptionInfraredFrameSourceEvents Events(this global::Windows.Devices.Perception.PerceptionInfraredFrameSource item) => new PerceptionInfraredFrameSourceEvents(item); + public static RxPerceptionInfraredFrameSourceEvents Events(this global::Windows.Devices.Perception.PerceptionInfraredFrameSource item) => new RxPerceptionInfraredFrameSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PerceptionInfraredFrameSourceWatcherEvents Events(this global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher item) => new PerceptionInfraredFrameSourceWatcherEvents(item); + public static RxPerceptionInfraredFrameSourceWatcherEvents Events(this global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher item) => new RxPerceptionInfraredFrameSourceWatcherEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class PerceptionColorFrameReaderEvents + public class RxPerceptionColorFrameReaderEvents { private readonly global::Windows.Devices.Perception.PerceptionColorFrameReader _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PerceptionColorFrameReaderEvents(global::Windows.Devices.Perception.PerceptionColorFrameReader data) + public RxPerceptionColorFrameReaderEvents(global::Windows.Devices.Perception.PerceptionColorFrameReader data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PerceptionColorFrameSourceEvents + public class RxPerceptionColorFrameSourceEvents { private readonly global::Windows.Devices.Perception.PerceptionColorFrameSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PerceptionColorFrameSourceEvents(global::Windows.Devices.Perception.PerceptionColorFrameSource data) + public RxPerceptionColorFrameSourceEvents(global::Windows.Devices.Perception.PerceptionColorFrameSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> ActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> CameraIntrinsicsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)> PropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)> VideoProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PerceptionColorFrameSourceWatcherEvents + public class RxPerceptionColorFrameSourceWatcherEvents { private readonly global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PerceptionColorFrameSourceWatcherEvents(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher data) + public RxPerceptionColorFrameSourceWatcherEvents(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args)> SourceAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args)> SourceRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PerceptionControlSessionEvents + public class RxPerceptionControlSessionEvents { private readonly global::Windows.Devices.Perception.PerceptionControlSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PerceptionControlSessionEvents(global::Windows.Devices.Perception.PerceptionControlSession data) + public RxPerceptionControlSessionEvents(global::Windows.Devices.Perception.PerceptionControlSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionControlSession sender, object args)> ControlLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionControlSession sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionControlSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ControlLost += x, x => _data.ControlLost -= x); + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PerceptionDepthFrameReaderEvents + public class RxPerceptionDepthFrameReaderEvents { private readonly global::Windows.Devices.Perception.PerceptionDepthFrameReader _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PerceptionDepthFrameReaderEvents(global::Windows.Devices.Perception.PerceptionDepthFrameReader data) + public RxPerceptionDepthFrameReaderEvents(global::Windows.Devices.Perception.PerceptionDepthFrameReader data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PerceptionDepthFrameSourceEvents + public class RxPerceptionDepthFrameSourceEvents { private readonly global::Windows.Devices.Perception.PerceptionDepthFrameSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PerceptionDepthFrameSourceEvents(global::Windows.Devices.Perception.PerceptionDepthFrameSource data) + public RxPerceptionDepthFrameSourceEvents(global::Windows.Devices.Perception.PerceptionDepthFrameSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> ActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> CameraIntrinsicsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)> PropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)> VideoProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PerceptionDepthFrameSourceWatcherEvents + public class RxPerceptionDepthFrameSourceWatcherEvents { private readonly global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PerceptionDepthFrameSourceWatcherEvents(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher data) + public RxPerceptionDepthFrameSourceWatcherEvents(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args)> SourceAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args)> SourceRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PerceptionInfraredFrameReaderEvents + public class RxPerceptionInfraredFrameReaderEvents { private readonly global::Windows.Devices.Perception.PerceptionInfraredFrameReader _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PerceptionInfraredFrameReaderEvents(global::Windows.Devices.Perception.PerceptionInfraredFrameReader data) + public RxPerceptionInfraredFrameReaderEvents(global::Windows.Devices.Perception.PerceptionInfraredFrameReader data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PerceptionInfraredFrameSourceEvents + public class RxPerceptionInfraredFrameSourceEvents { private readonly global::Windows.Devices.Perception.PerceptionInfraredFrameSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PerceptionInfraredFrameSourceEvents(global::Windows.Devices.Perception.PerceptionInfraredFrameSource data) + public RxPerceptionInfraredFrameSourceEvents(global::Windows.Devices.Perception.PerceptionInfraredFrameSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> ActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> AvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> CameraIntrinsicsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)> PropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)> VideoProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PerceptionInfraredFrameSourceWatcherEvents + public class RxPerceptionInfraredFrameSourceWatcherEvents { private readonly global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PerceptionInfraredFrameSourceWatcherEvents(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher data) + public RxPerceptionInfraredFrameSourceWatcherEvents(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args)> SourceAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args)> SourceRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -4277,504 +3891,450 @@ namespace Windows.Devices.PointOfService /// /// A wrapper class which wraps all the events contained within the class. /// - public static BarcodeScannerEvents Events(this global::Windows.Devices.PointOfService.BarcodeScanner item) => new BarcodeScannerEvents(item); + public static RxBarcodeScannerEvents Events(this global::Windows.Devices.PointOfService.BarcodeScanner item) => new RxBarcodeScannerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CashDrawerEvents Events(this global::Windows.Devices.PointOfService.CashDrawer item) => new CashDrawerEvents(item); + public static RxCashDrawerEvents Events(this global::Windows.Devices.PointOfService.CashDrawer item) => new RxCashDrawerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CashDrawerCloseAlarmEvents Events(this global::Windows.Devices.PointOfService.CashDrawerCloseAlarm item) => new CashDrawerCloseAlarmEvents(item); + public static RxCashDrawerCloseAlarmEvents Events(this global::Windows.Devices.PointOfService.CashDrawerCloseAlarm item) => new RxCashDrawerCloseAlarmEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CashDrawerEventSourceEvents Events(this global::Windows.Devices.PointOfService.CashDrawerEventSource item) => new CashDrawerEventSourceEvents(item); + public static RxCashDrawerEventSourceEvents Events(this global::Windows.Devices.PointOfService.CashDrawerEventSource item) => new RxCashDrawerEventSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ClaimedBarcodeScannerEvents Events(this global::Windows.Devices.PointOfService.ClaimedBarcodeScanner item) => new ClaimedBarcodeScannerEvents(item); + public static RxClaimedBarcodeScannerEvents Events(this global::Windows.Devices.PointOfService.ClaimedBarcodeScanner item) => new RxClaimedBarcodeScannerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ClaimedCashDrawerEvents Events(this global::Windows.Devices.PointOfService.ClaimedCashDrawer item) => new ClaimedCashDrawerEvents(item); + public static RxClaimedCashDrawerEvents Events(this global::Windows.Devices.PointOfService.ClaimedCashDrawer item) => new RxClaimedCashDrawerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ClaimedLineDisplayEvents Events(this global::Windows.Devices.PointOfService.ClaimedLineDisplay item) => new ClaimedLineDisplayEvents(item); + public static RxClaimedLineDisplayEvents Events(this global::Windows.Devices.PointOfService.ClaimedLineDisplay item) => new RxClaimedLineDisplayEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ClaimedMagneticStripeReaderEvents Events(this global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader item) => new ClaimedMagneticStripeReaderEvents(item); + public static RxClaimedMagneticStripeReaderEvents Events(this global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader item) => new RxClaimedMagneticStripeReaderEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ClaimedPosPrinterEvents Events(this global::Windows.Devices.PointOfService.ClaimedPosPrinter item) => new ClaimedPosPrinterEvents(item); + public static RxClaimedPosPrinterEvents Events(this global::Windows.Devices.PointOfService.ClaimedPosPrinter item) => new RxClaimedPosPrinterEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MagneticStripeReaderEvents Events(this global::Windows.Devices.PointOfService.MagneticStripeReader item) => new MagneticStripeReaderEvents(item); + public static RxMagneticStripeReaderEvents Events(this global::Windows.Devices.PointOfService.MagneticStripeReader item) => new RxMagneticStripeReaderEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PosPrinterEvents Events(this global::Windows.Devices.PointOfService.PosPrinter item) => new PosPrinterEvents(item); + public static RxPosPrinterEvents Events(this global::Windows.Devices.PointOfService.PosPrinter item) => new RxPosPrinterEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class BarcodeScannerEvents + public class RxBarcodeScannerEvents { private readonly global::Windows.Devices.PointOfService.BarcodeScanner _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BarcodeScannerEvents(global::Windows.Devices.PointOfService.BarcodeScanner data) + public RxBarcodeScannerEvents(global::Windows.Devices.PointOfService.BarcodeScanner data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CashDrawerEvents + public class RxCashDrawerEvents { private readonly global::Windows.Devices.PointOfService.CashDrawer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CashDrawerEvents(global::Windows.Devices.PointOfService.CashDrawer data) + public RxCashDrawerEvents(global::Windows.Devices.PointOfService.CashDrawer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CashDrawerCloseAlarmEvents + public class RxCashDrawerCloseAlarmEvents { private readonly global::Windows.Devices.PointOfService.CashDrawerCloseAlarm _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CashDrawerCloseAlarmEvents(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm data) + public RxCashDrawerCloseAlarmEvents(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args)> AlarmTimeoutExpired => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AlarmTimeoutExpired += x, x => _data.AlarmTimeoutExpired -= x); + }, x => _data.AlarmTimeoutExpired += x, x => _data.AlarmTimeoutExpired -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CashDrawerEventSourceEvents + public class RxCashDrawerEventSourceEvents { private readonly global::Windows.Devices.PointOfService.CashDrawerEventSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CashDrawerEventSourceEvents(global::Windows.Devices.PointOfService.CashDrawerEventSource data) + public RxCashDrawerEventSourceEvents(global::Windows.Devices.PointOfService.CashDrawerEventSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args)> DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); + }, x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args)> DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); + }, x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ClaimedBarcodeScannerEvents + public class RxClaimedBarcodeScannerEvents { private readonly global::Windows.Devices.PointOfService.ClaimedBarcodeScanner _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ClaimedBarcodeScannerEvents(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner data) + public RxClaimedBarcodeScannerEvents(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args)> DataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args)> ImagePreviewReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ImagePreviewReceived += x, x => _data.ImagePreviewReceived -= x); + }, x => _data.ImagePreviewReceived += x, x => _data.ImagePreviewReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner>(eventHandler => { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable TriggerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner>(eventHandler => { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); return Handler; - } - - , x => _data.TriggerPressed += x, x => _data.TriggerPressed -= x); + }, x => _data.TriggerPressed += x, x => _data.TriggerPressed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable TriggerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner>(eventHandler => { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); return Handler; - } - - , x => _data.TriggerReleased += x, x => _data.TriggerReleased -= x); + }, x => _data.TriggerReleased += x, x => _data.TriggerReleased -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ClaimedCashDrawerEvents + public class RxClaimedCashDrawerEvents { private readonly global::Windows.Devices.PointOfService.ClaimedCashDrawer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ClaimedCashDrawerEvents(global::Windows.Devices.PointOfService.ClaimedCashDrawer data) + public RxClaimedCashDrawerEvents(global::Windows.Devices.PointOfService.ClaimedCashDrawer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args)> ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ClaimedLineDisplayEvents + public class RxClaimedLineDisplayEvents { private readonly global::Windows.Devices.PointOfService.ClaimedLineDisplay _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ClaimedLineDisplayEvents(global::Windows.Devices.PointOfService.ClaimedLineDisplay data) + public RxClaimedLineDisplayEvents(global::Windows.Devices.PointOfService.ClaimedLineDisplay data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args)> ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ClaimedMagneticStripeReaderEvents + public class RxClaimedMagneticStripeReaderEvents { private readonly global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ClaimedMagneticStripeReaderEvents(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader data) + public RxClaimedMagneticStripeReaderEvents(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args)> AamvaCardDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AamvaCardDataReceived += x, x => _data.AamvaCardDataReceived -= x); + }, x => _data.AamvaCardDataReceived += x, x => _data.AamvaCardDataReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args)> BankCardDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BankCardDataReceived += x, x => _data.BankCardDataReceived -= x); + }, x => _data.BankCardDataReceived += x, x => _data.BankCardDataReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader>(eventHandler => { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader e) => eventHandler(e); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args)> VendorSpecificDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VendorSpecificDataReceived += x, x => _data.VendorSpecificDataReceived -= x); + }, x => _data.VendorSpecificDataReceived += x, x => _data.VendorSpecificDataReceived -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ClaimedPosPrinterEvents + public class RxClaimedPosPrinterEvents { private readonly global::Windows.Devices.PointOfService.ClaimedPosPrinter _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ClaimedPosPrinterEvents(global::Windows.Devices.PointOfService.ClaimedPosPrinter data) + public RxClaimedPosPrinterEvents(global::Windows.Devices.PointOfService.ClaimedPosPrinter data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args)> ReleaseDeviceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MagneticStripeReaderEvents + public class RxMagneticStripeReaderEvents { private readonly global::Windows.Devices.PointOfService.MagneticStripeReader _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MagneticStripeReaderEvents(global::Windows.Devices.PointOfService.MagneticStripeReader data) + public RxMagneticStripeReaderEvents(global::Windows.Devices.PointOfService.MagneticStripeReader data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PosPrinterEvents + public class RxPosPrinterEvents { private readonly global::Windows.Devices.PointOfService.PosPrinter _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PosPrinterEvents(global::Windows.Devices.PointOfService.PosPrinter data) + public RxPosPrinterEvents(global::Windows.Devices.PointOfService.PosPrinter data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args)> StatusUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } } @@ -4788,135 +4348,117 @@ namespace Windows.Devices.PointOfService.Provider /// /// A wrapper class which wraps all the events contained within the class. /// - public static BarcodeScannerFrameReaderEvents Events(this global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader item) => new BarcodeScannerFrameReaderEvents(item); + public static RxBarcodeScannerFrameReaderEvents Events(this global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader item) => new RxBarcodeScannerFrameReaderEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static BarcodeScannerProviderConnectionEvents Events(this global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection item) => new BarcodeScannerProviderConnectionEvents(item); + public static RxBarcodeScannerProviderConnectionEvents Events(this global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection item) => new RxBarcodeScannerProviderConnectionEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class BarcodeScannerFrameReaderEvents + public class RxBarcodeScannerFrameReaderEvents { private readonly global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BarcodeScannerFrameReaderEvents(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader data) + public RxBarcodeScannerFrameReaderEvents(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class BarcodeScannerProviderConnectionEvents + public class RxBarcodeScannerProviderConnectionEvents { private readonly global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BarcodeScannerProviderConnectionEvents(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection data) + public RxBarcodeScannerProviderConnectionEvents(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args)> DisableScannerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisableScannerRequested += x, x => _data.DisableScannerRequested -= x); + }, x => _data.DisableScannerRequested += x, x => _data.DisableScannerRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args)> EnableScannerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnableScannerRequested += x, x => _data.EnableScannerRequested -= x); + }, x => _data.EnableScannerRequested += x, x => _data.EnableScannerRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args)> GetBarcodeSymbologyAttributesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GetBarcodeSymbologyAttributesRequested += x, x => _data.GetBarcodeSymbologyAttributesRequested -= x); + }, x => _data.GetBarcodeSymbologyAttributesRequested += x, x => _data.GetBarcodeSymbologyAttributesRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args)> HideVideoPreviewRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HideVideoPreviewRequested += x, x => _data.HideVideoPreviewRequested -= x); + }, x => _data.HideVideoPreviewRequested += x, x => _data.HideVideoPreviewRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args)> SetActiveSymbologiesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetActiveSymbologiesRequested += x, x => _data.SetActiveSymbologiesRequested -= x); + }, x => _data.SetActiveSymbologiesRequested += x, x => _data.SetActiveSymbologiesRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args)> SetBarcodeSymbologyAttributesRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetBarcodeSymbologyAttributesRequested += x, x => _data.SetBarcodeSymbologyAttributesRequested -= x); + }, x => _data.SetBarcodeSymbologyAttributesRequested += x, x => _data.SetBarcodeSymbologyAttributesRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args)> StartSoftwareTriggerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StartSoftwareTriggerRequested += x, x => _data.StartSoftwareTriggerRequested -= x); + }, x => _data.StartSoftwareTriggerRequested += x, x => _data.StartSoftwareTriggerRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args)> StopSoftwareTriggerRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StopSoftwareTriggerRequested += x, x => _data.StopSoftwareTriggerRequested -= x); + }, x => _data.StopSoftwareTriggerRequested += x, x => _data.StopSoftwareTriggerRequested -= x); } } @@ -4930,34 +4472,32 @@ namespace Windows.Devices.Power /// /// A wrapper class which wraps all the events contained within the class. /// - public static BatteryEvents Events(this global::Windows.Devices.Power.Battery item) => new BatteryEvents(item); + public static RxBatteryEvents Events(this global::Windows.Devices.Power.Battery item) => new RxBatteryEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class BatteryEvents + public class RxBatteryEvents { private readonly global::Windows.Devices.Power.Battery _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BatteryEvents(global::Windows.Devices.Power.Battery data) + public RxBatteryEvents(global::Windows.Devices.Power.Battery data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Power.Battery sender, object args)> ReportUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Power.Battery sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Power.Battery sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReportUpdated += x, x => _data.ReportUpdated -= x); + }, x => _data.ReportUpdated += x, x => _data.ReportUpdated -= x); } } @@ -4971,44 +4511,40 @@ namespace Windows.Devices.Printers.Extensions /// /// A wrapper class which wraps all the events contained within the class. /// - public static Print3DWorkflowEvents Events(this global::Windows.Devices.Printers.Extensions.Print3DWorkflow item) => new Print3DWorkflowEvents(item); + public static RxPrint3DWorkflowEvents Events(this global::Windows.Devices.Printers.Extensions.Print3DWorkflow item) => new RxPrint3DWorkflowEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class Print3DWorkflowEvents + public class RxPrint3DWorkflowEvents { private readonly global::Windows.Devices.Printers.Extensions.Print3DWorkflow _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public Print3DWorkflowEvents(global::Windows.Devices.Printers.Extensions.Print3DWorkflow data) + public RxPrint3DWorkflowEvents(global::Windows.Devices.Printers.Extensions.Print3DWorkflow data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args)> PrinterChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrinterChanged += x, x => _data.PrinterChanged -= x); + }, x => _data.PrinterChanged += x, x => _data.PrinterChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args)> PrintRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrintRequested += x, x => _data.PrintRequested -= x); + }, x => _data.PrintRequested += x, x => _data.PrintRequested -= x); } } @@ -5022,34 +4558,32 @@ namespace Windows.Devices.Radios /// /// A wrapper class which wraps all the events contained within the class. /// - public static RadioEvents Events(this global::Windows.Devices.Radios.Radio item) => new RadioEvents(item); + public static RxRadioEvents Events(this global::Windows.Devices.Radios.Radio item) => new RxRadioEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class RadioEvents + public class RxRadioEvents { private readonly global::Windows.Devices.Radios.Radio _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RadioEvents(global::Windows.Devices.Radios.Radio data) + public RxRadioEvents(global::Windows.Devices.Radios.Radio data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Radios.Radio sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Radios.Radio sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Radios.Radio sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -5063,447 +4597,417 @@ namespace Windows.Devices.Sensors /// /// A wrapper class which wraps all the events contained within the class. /// - public static AccelerometerEvents Events(this global::Windows.Devices.Sensors.Accelerometer item) => new AccelerometerEvents(item); + public static RxAccelerometerEvents Events(this global::Windows.Devices.Sensors.Accelerometer item) => new RxAccelerometerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ActivitySensorEvents Events(this global::Windows.Devices.Sensors.ActivitySensor item) => new ActivitySensorEvents(item); + public static RxActivitySensorEvents Events(this global::Windows.Devices.Sensors.ActivitySensor item) => new RxActivitySensorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AltimeterEvents Events(this global::Windows.Devices.Sensors.Altimeter item) => new AltimeterEvents(item); + public static RxAltimeterEvents Events(this global::Windows.Devices.Sensors.Altimeter item) => new RxAltimeterEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static BarometerEvents Events(this global::Windows.Devices.Sensors.Barometer item) => new BarometerEvents(item); + public static RxBarometerEvents Events(this global::Windows.Devices.Sensors.Barometer item) => new RxBarometerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CompassEvents Events(this global::Windows.Devices.Sensors.Compass item) => new CompassEvents(item); + public static RxCompassEvents Events(this global::Windows.Devices.Sensors.Compass item) => new RxCompassEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GyrometerEvents Events(this global::Windows.Devices.Sensors.Gyrometer item) => new GyrometerEvents(item); + public static RxGyrometerEvents Events(this global::Windows.Devices.Sensors.Gyrometer item) => new RxGyrometerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static HingeAngleSensorEvents Events(this global::Windows.Devices.Sensors.HingeAngleSensor item) => new HingeAngleSensorEvents(item); + public static RxHingeAngleSensorEvents Events(this global::Windows.Devices.Sensors.HingeAngleSensor item) => new RxHingeAngleSensorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static InclinometerEvents Events(this global::Windows.Devices.Sensors.Inclinometer item) => new InclinometerEvents(item); + public static RxInclinometerEvents Events(this global::Windows.Devices.Sensors.Inclinometer item) => new RxInclinometerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static LightSensorEvents Events(this global::Windows.Devices.Sensors.LightSensor item) => new LightSensorEvents(item); + public static RxLightSensorEvents Events(this global::Windows.Devices.Sensors.LightSensor item) => new RxLightSensorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MagnetometerEvents Events(this global::Windows.Devices.Sensors.Magnetometer item) => new MagnetometerEvents(item); + public static RxMagnetometerEvents Events(this global::Windows.Devices.Sensors.Magnetometer item) => new RxMagnetometerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static OrientationSensorEvents Events(this global::Windows.Devices.Sensors.OrientationSensor item) => new OrientationSensorEvents(item); + public static RxOrientationSensorEvents Events(this global::Windows.Devices.Sensors.OrientationSensor item) => new RxOrientationSensorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PedometerEvents Events(this global::Windows.Devices.Sensors.Pedometer item) => new PedometerEvents(item); + public static RxPedometerEvents Events(this global::Windows.Devices.Sensors.Pedometer item) => new RxPedometerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ProximitySensorEvents Events(this global::Windows.Devices.Sensors.ProximitySensor item) => new ProximitySensorEvents(item); + public static RxProximitySensorEvents Events(this global::Windows.Devices.Sensors.ProximitySensor item) => new RxProximitySensorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SimpleOrientationSensorEvents Events(this global::Windows.Devices.Sensors.SimpleOrientationSensor item) => new SimpleOrientationSensorEvents(item); + public static RxSimpleOrientationSensorEvents Events(this global::Windows.Devices.Sensors.SimpleOrientationSensor item) => new RxSimpleOrientationSensorEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AccelerometerEvents + public class RxAccelerometerEvents { private readonly global::Windows.Devices.Sensors.Accelerometer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AccelerometerEvents(global::Windows.Devices.Sensors.Accelerometer data) + public RxAccelerometerEvents(global::Windows.Devices.Sensors.Accelerometer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args)> Shaken => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Shaken += x, x => _data.Shaken -= x); + }, x => _data.Shaken += x, x => _data.Shaken -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ActivitySensorEvents + public class RxActivitySensorEvents { private readonly global::Windows.Devices.Sensors.ActivitySensor _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ActivitySensorEvents(global::Windows.Devices.Sensors.ActivitySensor data) + public RxActivitySensorEvents(global::Windows.Devices.Sensors.ActivitySensor data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AltimeterEvents + public class RxAltimeterEvents { private readonly global::Windows.Devices.Sensors.Altimeter _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AltimeterEvents(global::Windows.Devices.Sensors.Altimeter data) + public RxAltimeterEvents(global::Windows.Devices.Sensors.Altimeter data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class BarometerEvents + public class RxBarometerEvents { private readonly global::Windows.Devices.Sensors.Barometer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BarometerEvents(global::Windows.Devices.Sensors.Barometer data) + public RxBarometerEvents(global::Windows.Devices.Sensors.Barometer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CompassEvents + public class RxCompassEvents { private readonly global::Windows.Devices.Sensors.Compass _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CompassEvents(global::Windows.Devices.Sensors.Compass data) + public RxCompassEvents(global::Windows.Devices.Sensors.Compass data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GyrometerEvents + public class RxGyrometerEvents { private readonly global::Windows.Devices.Sensors.Gyrometer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GyrometerEvents(global::Windows.Devices.Sensors.Gyrometer data) + public RxGyrometerEvents(global::Windows.Devices.Sensors.Gyrometer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class HingeAngleSensorEvents + public class RxHingeAngleSensorEvents { private readonly global::Windows.Devices.Sensors.HingeAngleSensor _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public HingeAngleSensorEvents(global::Windows.Devices.Sensors.HingeAngleSensor data) + public RxHingeAngleSensorEvents(global::Windows.Devices.Sensors.HingeAngleSensor data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class InclinometerEvents + public class RxInclinometerEvents { private readonly global::Windows.Devices.Sensors.Inclinometer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public InclinometerEvents(global::Windows.Devices.Sensors.Inclinometer data) + public RxInclinometerEvents(global::Windows.Devices.Sensors.Inclinometer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class LightSensorEvents + public class RxLightSensorEvents { private readonly global::Windows.Devices.Sensors.LightSensor _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public LightSensorEvents(global::Windows.Devices.Sensors.LightSensor data) + public RxLightSensorEvents(global::Windows.Devices.Sensors.LightSensor data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MagnetometerEvents + public class RxMagnetometerEvents { private readonly global::Windows.Devices.Sensors.Magnetometer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MagnetometerEvents(global::Windows.Devices.Sensors.Magnetometer data) + public RxMagnetometerEvents(global::Windows.Devices.Sensors.Magnetometer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class OrientationSensorEvents + public class RxOrientationSensorEvents { private readonly global::Windows.Devices.Sensors.OrientationSensor _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public OrientationSensorEvents(global::Windows.Devices.Sensors.OrientationSensor data) + public RxOrientationSensorEvents(global::Windows.Devices.Sensors.OrientationSensor data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PedometerEvents + public class RxPedometerEvents { private readonly global::Windows.Devices.Sensors.Pedometer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PedometerEvents(global::Windows.Devices.Sensors.Pedometer data) + public RxPedometerEvents(global::Windows.Devices.Sensors.Pedometer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ProximitySensorEvents + public class RxProximitySensorEvents { private readonly global::Windows.Devices.Sensors.ProximitySensor _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ProximitySensorEvents(global::Windows.Devices.Sensors.ProximitySensor data) + public RxProximitySensorEvents(global::Windows.Devices.Sensors.ProximitySensor data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SimpleOrientationSensorEvents + public class RxSimpleOrientationSensorEvents { private readonly global::Windows.Devices.Sensors.SimpleOrientationSensor _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SimpleOrientationSensorEvents(global::Windows.Devices.Sensors.SimpleOrientationSensor data) + public RxSimpleOrientationSensorEvents(global::Windows.Devices.Sensors.SimpleOrientationSensor data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args)> OrientationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); } } @@ -5517,34 +5021,32 @@ namespace Windows.Devices.Sensors.Custom /// /// A wrapper class which wraps all the events contained within the class. /// - public static CustomSensorEvents Events(this global::Windows.Devices.Sensors.Custom.CustomSensor item) => new CustomSensorEvents(item); + public static RxCustomSensorEvents Events(this global::Windows.Devices.Sensors.Custom.CustomSensor item) => new RxCustomSensorEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class CustomSensorEvents + public class RxCustomSensorEvents { private readonly global::Windows.Devices.Sensors.Custom.CustomSensor _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CustomSensorEvents(global::Windows.Devices.Sensors.Custom.CustomSensor data) + public RxCustomSensorEvents(global::Windows.Devices.Sensors.Custom.CustomSensor data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args)> ReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } } @@ -5558,44 +5060,40 @@ namespace Windows.Devices.SerialCommunication /// /// A wrapper class which wraps all the events contained within the class. /// - public static SerialDeviceEvents Events(this global::Windows.Devices.SerialCommunication.SerialDevice item) => new SerialDeviceEvents(item); + public static RxSerialDeviceEvents Events(this global::Windows.Devices.SerialCommunication.SerialDevice item) => new RxSerialDeviceEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class SerialDeviceEvents + public class RxSerialDeviceEvents { private readonly global::Windows.Devices.SerialCommunication.SerialDevice _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SerialDeviceEvents(global::Windows.Devices.SerialCommunication.SerialDevice data) + public RxSerialDeviceEvents(global::Windows.Devices.SerialCommunication.SerialDevice data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args)> ErrorReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorReceived += x, x => _data.ErrorReceived -= x); + }, x => _data.ErrorReceived += x, x => _data.ErrorReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args)> PinChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PinChanged += x, x => _data.PinChanged -= x); + }, x => _data.PinChanged += x, x => _data.PinChanged -= x); } } @@ -5609,44 +5107,40 @@ namespace Windows.Devices.SmartCards /// /// A wrapper class which wraps all the events contained within the class. /// - public static SmartCardReaderEvents Events(this global::Windows.Devices.SmartCards.SmartCardReader item) => new SmartCardReaderEvents(item); + public static RxSmartCardReaderEvents Events(this global::Windows.Devices.SmartCards.SmartCardReader item) => new RxSmartCardReaderEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class SmartCardReaderEvents + public class RxSmartCardReaderEvents { private readonly global::Windows.Devices.SmartCards.SmartCardReader _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SmartCardReaderEvents(global::Windows.Devices.SmartCards.SmartCardReader data) + public RxSmartCardReaderEvents(global::Windows.Devices.SmartCards.SmartCardReader data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args)> CardAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CardAdded += x, x => _data.CardAdded -= x); + }, x => _data.CardAdded += x, x => _data.CardAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args)> CardRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CardRemoved += x, x => _data.CardRemoved -= x); + }, x => _data.CardRemoved += x, x => _data.CardRemoved -= x); } } @@ -5660,65 +5154,61 @@ namespace Windows.Devices.Sms /// /// A wrapper class which wraps all the events contained within the class. /// - public static SmsDevice2Events Events(this global::Windows.Devices.Sms.SmsDevice2 item) => new SmsDevice2Events(item); + public static RxSmsDevice2Events Events(this global::Windows.Devices.Sms.SmsDevice2 item) => new RxSmsDevice2Events(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SmsMessageRegistrationEvents Events(this global::Windows.Devices.Sms.SmsMessageRegistration item) => new SmsMessageRegistrationEvents(item); + public static RxSmsMessageRegistrationEvents Events(this global::Windows.Devices.Sms.SmsMessageRegistration item) => new RxSmsMessageRegistrationEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class SmsDevice2Events + public class RxSmsDevice2Events { private readonly global::Windows.Devices.Sms.SmsDevice2 _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SmsDevice2Events(global::Windows.Devices.Sms.SmsDevice2 data) + public RxSmsDevice2Events(global::Windows.Devices.Sms.SmsDevice2 data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sms.SmsDevice2 sender, object args)> DeviceStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sms.SmsDevice2 sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.Sms.SmsDevice2 sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeviceStatusChanged += x, x => _data.DeviceStatusChanged -= x); + }, x => _data.DeviceStatusChanged += x, x => _data.DeviceStatusChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SmsMessageRegistrationEvents + public class RxSmsMessageRegistrationEvents { private readonly global::Windows.Devices.Sms.SmsMessageRegistration _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SmsMessageRegistrationEvents(global::Windows.Devices.Sms.SmsMessageRegistration data) + public RxSmsMessageRegistrationEvents(global::Windows.Devices.Sms.SmsMessageRegistration data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args)>(eventHandler => { void Handler(global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } } @@ -5732,34 +5222,32 @@ namespace Windows.Devices.Usb /// /// A wrapper class which wraps all the events contained within the class. /// - public static UsbInterruptInPipeEvents Events(this global::Windows.Devices.Usb.UsbInterruptInPipe item) => new UsbInterruptInPipeEvents(item); + public static RxUsbInterruptInPipeEvents Events(this global::Windows.Devices.Usb.UsbInterruptInPipe item) => new RxUsbInterruptInPipeEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class UsbInterruptInPipeEvents + public class RxUsbInterruptInPipeEvents { private readonly global::Windows.Devices.Usb.UsbInterruptInPipe _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public UsbInterruptInPipeEvents(global::Windows.Devices.Usb.UsbInterruptInPipe data) + public RxUsbInterruptInPipeEvents(global::Windows.Devices.Usb.UsbInterruptInPipe data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args)> DataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); } } @@ -5773,34 +5261,32 @@ namespace Windows.Devices.WiFi /// /// A wrapper class which wraps all the events contained within the class. /// - public static WiFiAdapterEvents Events(this global::Windows.Devices.WiFi.WiFiAdapter item) => new WiFiAdapterEvents(item); + public static RxWiFiAdapterEvents Events(this global::Windows.Devices.WiFi.WiFiAdapter item) => new RxWiFiAdapterEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class WiFiAdapterEvents + public class RxWiFiAdapterEvents { private readonly global::Windows.Devices.WiFi.WiFiAdapter _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WiFiAdapterEvents(global::Windows.Devices.WiFi.WiFiAdapter data) + public RxWiFiAdapterEvents(global::Windows.Devices.WiFi.WiFiAdapter data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.WiFi.WiFiAdapter sender, object args)> AvailableNetworksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFi.WiFiAdapter sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.WiFi.WiFiAdapter sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableNetworksChanged += x, x => _data.AvailableNetworksChanged -= x); + }, x => _data.AvailableNetworksChanged += x, x => _data.AvailableNetworksChanged -= x); } } @@ -5814,96 +5300,90 @@ namespace Windows.Devices.WiFiDirect /// /// A wrapper class which wraps all the events contained within the class. /// - public static WiFiDirectAdvertisementPublisherEvents Events(this global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher item) => new WiFiDirectAdvertisementPublisherEvents(item); + public static RxWiFiDirectAdvertisementPublisherEvents Events(this global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher item) => new RxWiFiDirectAdvertisementPublisherEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static WiFiDirectConnectionListenerEvents Events(this global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener item) => new WiFiDirectConnectionListenerEvents(item); + public static RxWiFiDirectConnectionListenerEvents Events(this global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener item) => new RxWiFiDirectConnectionListenerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static WiFiDirectDeviceEvents Events(this global::Windows.Devices.WiFiDirect.WiFiDirectDevice item) => new WiFiDirectDeviceEvents(item); + public static RxWiFiDirectDeviceEvents Events(this global::Windows.Devices.WiFiDirect.WiFiDirectDevice item) => new RxWiFiDirectDeviceEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class WiFiDirectAdvertisementPublisherEvents + public class RxWiFiDirectAdvertisementPublisherEvents { private readonly global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WiFiDirectAdvertisementPublisherEvents(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher data) + public RxWiFiDirectAdvertisementPublisherEvents(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class WiFiDirectConnectionListenerEvents + public class RxWiFiDirectConnectionListenerEvents { private readonly global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WiFiDirectConnectionListenerEvents(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener data) + public RxWiFiDirectConnectionListenerEvents(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args)> ConnectionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); + }, x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class WiFiDirectDeviceEvents + public class RxWiFiDirectDeviceEvents { private readonly global::Windows.Devices.WiFiDirect.WiFiDirectDevice _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WiFiDirectDeviceEvents(global::Windows.Devices.WiFiDirect.WiFiDirectDevice data) + public RxWiFiDirectDeviceEvents(global::Windows.Devices.WiFiDirect.WiFiDirectDevice data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args)> ConnectionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); } } @@ -5917,126 +5397,114 @@ namespace Windows.Devices.WiFiDirect.Services /// /// A wrapper class which wraps all the events contained within the class. /// - public static WiFiDirectServiceEvents Events(this global::Windows.Devices.WiFiDirect.Services.WiFiDirectService item) => new WiFiDirectServiceEvents(item); + public static RxWiFiDirectServiceEvents Events(this global::Windows.Devices.WiFiDirect.Services.WiFiDirectService item) => new RxWiFiDirectServiceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static WiFiDirectServiceAdvertiserEvents Events(this global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser item) => new WiFiDirectServiceAdvertiserEvents(item); + public static RxWiFiDirectServiceAdvertiserEvents Events(this global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser item) => new RxWiFiDirectServiceAdvertiserEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static WiFiDirectServiceSessionEvents Events(this global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession item) => new WiFiDirectServiceSessionEvents(item); + public static RxWiFiDirectServiceSessionEvents Events(this global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession item) => new RxWiFiDirectServiceSessionEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class WiFiDirectServiceEvents + public class RxWiFiDirectServiceEvents { private readonly global::Windows.Devices.WiFiDirect.Services.WiFiDirectService _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WiFiDirectServiceEvents(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService data) + public RxWiFiDirectServiceEvents(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args)> SessionDeferred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionDeferred += x, x => _data.SessionDeferred -= x); + }, x => _data.SessionDeferred += x, x => _data.SessionDeferred -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class WiFiDirectServiceAdvertiserEvents + public class RxWiFiDirectServiceAdvertiserEvents { private readonly global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WiFiDirectServiceAdvertiserEvents(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser data) + public RxWiFiDirectServiceAdvertiserEvents(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args)> AdvertisementStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args)> AutoAcceptSessionConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutoAcceptSessionConnected += x, x => _data.AutoAcceptSessionConnected -= x); + }, x => _data.AutoAcceptSessionConnected += x, x => _data.AutoAcceptSessionConnected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args)> SessionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionRequested += x, x => _data.SessionRequested -= x); + }, x => _data.SessionRequested += x, x => _data.SessionRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class WiFiDirectServiceSessionEvents + public class RxWiFiDirectServiceSessionEvents { private readonly global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WiFiDirectServiceSessionEvents(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession data) + public RxWiFiDirectServiceSessionEvents(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args)> RemotePortAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args)>(eventHandler => { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemotePortAdded += x, x => _data.RemotePortAdded -= x); + }, x => _data.RemotePortAdded += x, x => _data.RemotePortAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args)> SessionStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args)>(eventHandler => { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); } } @@ -6050,34 +5518,32 @@ namespace Windows.Foundation /// /// A wrapper class which wraps all the events contained within the class. /// - public static IMemoryBufferReferenceEvents Events(this global::Windows.Foundation.IMemoryBufferReference item) => new IMemoryBufferReferenceEvents(item); + public static RxIMemoryBufferReferenceEvents Events(this global::Windows.Foundation.IMemoryBufferReference item) => new RxIMemoryBufferReferenceEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class IMemoryBufferReferenceEvents + public class RxIMemoryBufferReferenceEvents { private readonly global::Windows.Foundation.IMemoryBufferReference _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IMemoryBufferReferenceEvents(global::Windows.Foundation.IMemoryBufferReference data) + public RxIMemoryBufferReferenceEvents(global::Windows.Foundation.IMemoryBufferReference data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Foundation.IMemoryBufferReference sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.IMemoryBufferReference sender, object args)>(eventHandler => { void Handler(global::Windows.Foundation.IMemoryBufferReference sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } } @@ -6091,96 +5557,90 @@ namespace Windows.Foundation.Collections /// /// A wrapper class which wraps all the events contained within the class. /// - public static PropertySetEvents Events(this global::Windows.Foundation.Collections.PropertySet item) => new PropertySetEvents(item); + public static RxPropertySetEvents Events(this global::Windows.Foundation.Collections.PropertySet item) => new RxPropertySetEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static StringMapEvents Events(this global::Windows.Foundation.Collections.StringMap item) => new StringMapEvents(item); + public static RxStringMapEvents Events(this global::Windows.Foundation.Collections.StringMap item) => new RxStringMapEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ValueSetEvents Events(this global::Windows.Foundation.Collections.ValueSet item) => new ValueSetEvents(item); + public static RxValueSetEvents Events(this global::Windows.Foundation.Collections.ValueSet item) => new RxValueSetEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class PropertySetEvents + public class RxPropertySetEvents { private readonly global::Windows.Foundation.Collections.PropertySet _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PropertySetEvents(global::Windows.Foundation.Collections.PropertySet data) + public RxPropertySetEvents(global::Windows.Foundation.Collections.PropertySet data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class StringMapEvents + public class RxStringMapEvents { private readonly global::Windows.Foundation.Collections.StringMap _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public StringMapEvents(global::Windows.Foundation.Collections.StringMap data) + public RxStringMapEvents(global::Windows.Foundation.Collections.StringMap data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ValueSetEvents + public class RxValueSetEvents { private readonly global::Windows.Foundation.Collections.ValueSet _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ValueSetEvents(global::Windows.Foundation.Collections.ValueSet data) + public RxValueSetEvents(global::Windows.Foundation.Collections.ValueSet data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } } @@ -6194,127 +5654,119 @@ namespace Windows.Foundation.Diagnostics /// /// A wrapper class which wraps all the events contained within the class. /// - public static FileLoggingSessionEvents Events(this global::Windows.Foundation.Diagnostics.FileLoggingSession item) => new FileLoggingSessionEvents(item); + public static RxFileLoggingSessionEvents Events(this global::Windows.Foundation.Diagnostics.FileLoggingSession item) => new RxFileLoggingSessionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IFileLoggingSessionEvents Events(this global::Windows.Foundation.Diagnostics.IFileLoggingSession item) => new IFileLoggingSessionEvents(item); + public static RxIFileLoggingSessionEvents Events(this global::Windows.Foundation.Diagnostics.IFileLoggingSession item) => new RxIFileLoggingSessionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ILoggingChannelEvents Events(this global::Windows.Foundation.Diagnostics.ILoggingChannel item) => new ILoggingChannelEvents(item); + public static RxILoggingChannelEvents Events(this global::Windows.Foundation.Diagnostics.ILoggingChannel item) => new RxILoggingChannelEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static LoggingChannelEvents Events(this global::Windows.Foundation.Diagnostics.LoggingChannel item) => new LoggingChannelEvents(item); + public static RxLoggingChannelEvents Events(this global::Windows.Foundation.Diagnostics.LoggingChannel item) => new RxLoggingChannelEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class FileLoggingSessionEvents + public class RxFileLoggingSessionEvents { private readonly global::Windows.Foundation.Diagnostics.FileLoggingSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public FileLoggingSessionEvents(global::Windows.Foundation.Diagnostics.FileLoggingSession data) + public RxFileLoggingSessionEvents(global::Windows.Foundation.Diagnostics.FileLoggingSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)> LogFileGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)>(eventHandler => { void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IFileLoggingSessionEvents + public class RxIFileLoggingSessionEvents { private readonly global::Windows.Foundation.Diagnostics.IFileLoggingSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IFileLoggingSessionEvents(global::Windows.Foundation.Diagnostics.IFileLoggingSession data) + public RxIFileLoggingSessionEvents(global::Windows.Foundation.Diagnostics.IFileLoggingSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)> LogFileGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args)>(eventHandler => { void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ILoggingChannelEvents + public class RxILoggingChannelEvents { private readonly global::Windows.Foundation.Diagnostics.ILoggingChannel _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ILoggingChannelEvents(global::Windows.Foundation.Diagnostics.ILoggingChannel data) + public RxILoggingChannelEvents(global::Windows.Foundation.Diagnostics.ILoggingChannel data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)> LoggingEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)>(eventHandler => { void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class LoggingChannelEvents + public class RxLoggingChannelEvents { private readonly global::Windows.Foundation.Diagnostics.LoggingChannel _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public LoggingChannelEvents(global::Windows.Foundation.Diagnostics.LoggingChannel data) + public RxLoggingChannelEvents(global::Windows.Foundation.Diagnostics.LoggingChannel data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)> LoggingEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args)>(eventHandler => { void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); } } @@ -6328,360 +5780,318 @@ namespace Windows.Gaming.Input /// /// A wrapper class which wraps all the events contained within the class. /// - public static ArcadeStickEvents Events(this global::Windows.Gaming.Input.ArcadeStick item) => new ArcadeStickEvents(item); + public static RxArcadeStickEvents Events(this global::Windows.Gaming.Input.ArcadeStick item) => new RxArcadeStickEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static FlightStickEvents Events(this global::Windows.Gaming.Input.FlightStick item) => new FlightStickEvents(item); + public static RxFlightStickEvents Events(this global::Windows.Gaming.Input.FlightStick item) => new RxFlightStickEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GamepadEvents Events(this global::Windows.Gaming.Input.Gamepad item) => new GamepadEvents(item); + public static RxGamepadEvents Events(this global::Windows.Gaming.Input.Gamepad item) => new RxGamepadEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IGameControllerEvents Events(this global::Windows.Gaming.Input.IGameController item) => new IGameControllerEvents(item); + public static RxIGameControllerEvents Events(this global::Windows.Gaming.Input.IGameController item) => new RxIGameControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RacingWheelEvents Events(this global::Windows.Gaming.Input.RacingWheel item) => new RacingWheelEvents(item); + public static RxRacingWheelEvents Events(this global::Windows.Gaming.Input.RacingWheel item) => new RxRacingWheelEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RawGameControllerEvents Events(this global::Windows.Gaming.Input.RawGameController item) => new RawGameControllerEvents(item); + public static RxRawGameControllerEvents Events(this global::Windows.Gaming.Input.RawGameController item) => new RxRawGameControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static UINavigationControllerEvents Events(this global::Windows.Gaming.Input.UINavigationController item) => new UINavigationControllerEvents(item); + public static RxUINavigationControllerEvents Events(this global::Windows.Gaming.Input.UINavigationController item) => new RxUINavigationControllerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ArcadeStickEvents + public class RxArcadeStickEvents { private readonly global::Windows.Gaming.Input.ArcadeStick _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ArcadeStickEvents(global::Windows.Gaming.Input.ArcadeStick data) + public RxArcadeStickEvents(global::Windows.Gaming.Input.ArcadeStick data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class FlightStickEvents + public class RxFlightStickEvents { private readonly global::Windows.Gaming.Input.FlightStick _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public FlightStickEvents(global::Windows.Gaming.Input.FlightStick data) + public RxFlightStickEvents(global::Windows.Gaming.Input.FlightStick data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GamepadEvents + public class RxGamepadEvents { private readonly global::Windows.Gaming.Input.Gamepad _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GamepadEvents(global::Windows.Gaming.Input.Gamepad data) + public RxGamepadEvents(global::Windows.Gaming.Input.Gamepad data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IGameControllerEvents + public class RxIGameControllerEvents { private readonly global::Windows.Gaming.Input.IGameController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IGameControllerEvents(global::Windows.Gaming.Input.IGameController data) + public RxIGameControllerEvents(global::Windows.Gaming.Input.IGameController data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RacingWheelEvents + public class RxRacingWheelEvents { private readonly global::Windows.Gaming.Input.RacingWheel _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RacingWheelEvents(global::Windows.Gaming.Input.RacingWheel data) + public RxRacingWheelEvents(global::Windows.Gaming.Input.RacingWheel data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RawGameControllerEvents + public class RxRawGameControllerEvents { private readonly global::Windows.Gaming.Input.RawGameController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RawGameControllerEvents(global::Windows.Gaming.Input.RawGameController data) + public RxRawGameControllerEvents(global::Windows.Gaming.Input.RawGameController data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class UINavigationControllerEvents + public class RxUINavigationControllerEvents { private readonly global::Windows.Gaming.Input.UINavigationController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public UINavigationControllerEvents(global::Windows.Gaming.Input.UINavigationController data) + public RxUINavigationControllerEvents(global::Windows.Gaming.Input.UINavigationController data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetConnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)> HeadsetDisconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)> UserChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } } @@ -6695,65 +6105,61 @@ namespace Windows.Graphics.Capture /// /// A wrapper class which wraps all the events contained within the class. /// - public static Direct3D11CaptureFramePoolEvents Events(this global::Windows.Graphics.Capture.Direct3D11CaptureFramePool item) => new Direct3D11CaptureFramePoolEvents(item); + public static RxDirect3D11CaptureFramePoolEvents Events(this global::Windows.Graphics.Capture.Direct3D11CaptureFramePool item) => new RxDirect3D11CaptureFramePoolEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GraphicsCaptureItemEvents Events(this global::Windows.Graphics.Capture.GraphicsCaptureItem item) => new GraphicsCaptureItemEvents(item); + public static RxGraphicsCaptureItemEvents Events(this global::Windows.Graphics.Capture.GraphicsCaptureItem item) => new RxGraphicsCaptureItemEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class Direct3D11CaptureFramePoolEvents + public class RxDirect3D11CaptureFramePoolEvents { private readonly global::Windows.Graphics.Capture.Direct3D11CaptureFramePool _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public Direct3D11CaptureFramePoolEvents(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool data) + public RxDirect3D11CaptureFramePoolEvents(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GraphicsCaptureItemEvents + public class RxGraphicsCaptureItemEvents { private readonly global::Windows.Graphics.Capture.GraphicsCaptureItem _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GraphicsCaptureItemEvents(global::Windows.Graphics.Capture.GraphicsCaptureItem data) + public RxGraphicsCaptureItemEvents(global::Windows.Graphics.Capture.GraphicsCaptureItem data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } } @@ -6767,176 +6173,154 @@ namespace Windows.Graphics.Display /// /// A wrapper class which wraps all the events contained within the class. /// - public static BrightnessOverrideEvents Events(this global::Windows.Graphics.Display.BrightnessOverride item) => new BrightnessOverrideEvents(item); + public static RxBrightnessOverrideEvents Events(this global::Windows.Graphics.Display.BrightnessOverride item) => new RxBrightnessOverrideEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DisplayEnhancementOverrideEvents Events(this global::Windows.Graphics.Display.DisplayEnhancementOverride item) => new DisplayEnhancementOverrideEvents(item); + public static RxDisplayEnhancementOverrideEvents Events(this global::Windows.Graphics.Display.DisplayEnhancementOverride item) => new RxDisplayEnhancementOverrideEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DisplayInformationEvents Events(this global::Windows.Graphics.Display.DisplayInformation item) => new DisplayInformationEvents(item); + public static RxDisplayInformationEvents Events(this global::Windows.Graphics.Display.DisplayInformation item) => new RxDisplayInformationEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class BrightnessOverrideEvents + public class RxBrightnessOverrideEvents { private readonly global::Windows.Graphics.Display.BrightnessOverride _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BrightnessOverrideEvents(global::Windows.Graphics.Display.BrightnessOverride data) + public RxBrightnessOverrideEvents(global::Windows.Graphics.Display.BrightnessOverride data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Display.BrightnessOverride sender, object args)> BrightnessLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.BrightnessOverride sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BrightnessLevelChanged += x, x => _data.BrightnessLevelChanged -= x); + }, x => _data.BrightnessLevelChanged += x, x => _data.BrightnessLevelChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Display.BrightnessOverride sender, object args)> IsOverrideActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.BrightnessOverride sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Display.BrightnessOverride sender, object args)> IsSupportedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.BrightnessOverride sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); + }, x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DisplayEnhancementOverrideEvents + public class RxDisplayEnhancementOverrideEvents { private readonly global::Windows.Graphics.Display.DisplayEnhancementOverride _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DisplayEnhancementOverrideEvents(global::Windows.Graphics.Display.DisplayEnhancementOverride data) + public RxDisplayEnhancementOverrideEvents(global::Windows.Graphics.Display.DisplayEnhancementOverride data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)> CanOverrideChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CanOverrideChanged += x, x => _data.CanOverrideChanged -= x); + }, x => _data.CanOverrideChanged += x, x => _data.CanOverrideChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args)> DisplayEnhancementOverrideCapabilitiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisplayEnhancementOverrideCapabilitiesChanged += x, x => _data.DisplayEnhancementOverrideCapabilitiesChanged -= x); + }, x => _data.DisplayEnhancementOverrideCapabilitiesChanged += x, x => _data.DisplayEnhancementOverrideCapabilitiesChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)> IsOverrideActiveChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DisplayInformationEvents + public class RxDisplayInformationEvents { private readonly global::Windows.Graphics.Display.DisplayInformation _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DisplayInformationEvents(global::Windows.Graphics.Display.DisplayInformation data) + public RxDisplayInformationEvents(global::Windows.Graphics.Display.DisplayInformation data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> AdvancedColorInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvancedColorInfoChanged += x, x => _data.AdvancedColorInfoChanged -= x); + }, x => _data.AdvancedColorInfoChanged += x, x => _data.AdvancedColorInfoChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> ColorProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorProfileChanged += x, x => _data.ColorProfileChanged -= x); + }, x => _data.ColorProfileChanged += x, x => _data.ColorProfileChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> DpiChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> OrientationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> StereoEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StereoEnabledChanged += x, x => _data.StereoEnabledChanged -= x); + }, x => _data.StereoEnabledChanged += x, x => _data.StereoEnabledChanged -= x); } } @@ -6950,34 +6334,32 @@ namespace Windows.Graphics.Display.Core /// /// A wrapper class which wraps all the events contained within the class. /// - public static HdmiDisplayInformationEvents Events(this global::Windows.Graphics.Display.Core.HdmiDisplayInformation item) => new HdmiDisplayInformationEvents(item); + public static RxHdmiDisplayInformationEvents Events(this global::Windows.Graphics.Display.Core.HdmiDisplayInformation item) => new RxHdmiDisplayInformationEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class HdmiDisplayInformationEvents + public class RxHdmiDisplayInformationEvents { private readonly global::Windows.Graphics.Display.Core.HdmiDisplayInformation _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public HdmiDisplayInformationEvents(global::Windows.Graphics.Display.Core.HdmiDisplayInformation data) + public RxHdmiDisplayInformationEvents(global::Windows.Graphics.Display.Core.HdmiDisplayInformation data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args)> DisplayModesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisplayModesChanged += x, x => _data.DisplayModesChanged -= x); + }, x => _data.DisplayModesChanged += x, x => _data.DisplayModesChanged -= x); } } @@ -6991,54 +6373,48 @@ namespace Windows.Graphics.Holographic /// /// A wrapper class which wraps all the events contained within the class. /// - public static HolographicSpaceEvents Events(this global::Windows.Graphics.Holographic.HolographicSpace item) => new HolographicSpaceEvents(item); + public static RxHolographicSpaceEvents Events(this global::Windows.Graphics.Holographic.HolographicSpace item) => new RxHolographicSpaceEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class HolographicSpaceEvents + public class RxHolographicSpaceEvents { private readonly global::Windows.Graphics.Holographic.HolographicSpace _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public HolographicSpaceEvents(global::Windows.Graphics.Holographic.HolographicSpace data) + public RxHolographicSpaceEvents(global::Windows.Graphics.Holographic.HolographicSpace data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args)> CameraAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args)>(eventHandler => { void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraAdded += x, x => _data.CameraAdded -= x); + }, x => _data.CameraAdded += x, x => _data.CameraAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args)> CameraRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args)>(eventHandler => { void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraRemoved += x, x => _data.CameraRemoved -= x); + }, x => _data.CameraRemoved += x, x => _data.CameraRemoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Holographic.HolographicSpace sender, object args)> UserPresenceChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Holographic.HolographicSpace sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserPresenceChanged += x, x => _data.UserPresenceChanged -= x); + }, x => _data.UserPresenceChanged += x, x => _data.UserPresenceChanged -= x); } } @@ -7052,95 +6428,85 @@ namespace Windows.Graphics.Printing /// /// A wrapper class which wraps all the events contained within the class. /// - public static PrintManagerEvents Events(this global::Windows.Graphics.Printing.PrintManager item) => new PrintManagerEvents(item); + public static RxPrintManagerEvents Events(this global::Windows.Graphics.Printing.PrintManager item) => new RxPrintManagerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PrintTaskEvents Events(this global::Windows.Graphics.Printing.PrintTask item) => new PrintTaskEvents(item); + public static RxPrintTaskEvents Events(this global::Windows.Graphics.Printing.PrintTask item) => new RxPrintTaskEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class PrintManagerEvents + public class RxPrintManagerEvents { private readonly global::Windows.Graphics.Printing.PrintManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PrintManagerEvents(global::Windows.Graphics.Printing.PrintManager data) + public RxPrintManagerEvents(global::Windows.Graphics.Printing.PrintManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args)> PrintTaskRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrintTaskRequested += x, x => _data.PrintTaskRequested -= x); + }, x => _data.PrintTaskRequested += x, x => _data.PrintTaskRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PrintTaskEvents + public class RxPrintTaskEvents { private readonly global::Windows.Graphics.Printing.PrintTask _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PrintTaskEvents(global::Windows.Graphics.Printing.PrintTask data) + public RxPrintTaskEvents(global::Windows.Graphics.Printing.PrintTask data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, object args)> Previewing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Previewing += x, x => _data.Previewing -= x); + }, x => _data.Previewing += x, x => _data.Previewing -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args)> Progressing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args)>(eventHandler => { void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Progressing += x, x => _data.Progressing -= x); + }, x => _data.Progressing += x, x => _data.Progressing -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Printing.PrintTask sender, object args)> Submitting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.PrintTask sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Submitting += x, x => _data.Submitting -= x); + }, x => _data.Submitting += x, x => _data.Submitting -= x); } } @@ -7154,44 +6520,40 @@ namespace Windows.Graphics.Printing.OptionDetails /// /// A wrapper class which wraps all the events contained within the class. /// - public static PrintTaskOptionDetailsEvents Events(this global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails item) => new PrintTaskOptionDetailsEvents(item); + public static RxPrintTaskOptionDetailsEvents Events(this global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails item) => new RxPrintTaskOptionDetailsEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class PrintTaskOptionDetailsEvents + public class RxPrintTaskOptionDetailsEvents { private readonly global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PrintTaskOptionDetailsEvents(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails data) + public RxPrintTaskOptionDetailsEvents(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args)> BeginValidation => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BeginValidation += x, x => _data.BeginValidation -= x); + }, x => _data.BeginValidation += x, x => _data.BeginValidation -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args)> OptionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionChanged += x, x => _data.OptionChanged -= x); + }, x => _data.OptionChanged += x, x => _data.OptionChanged -= x); } } @@ -7205,85 +6567,77 @@ namespace Windows.Graphics.Printing.Workflow /// /// A wrapper class which wraps all the events contained within the class. /// - public static PrintWorkflowBackgroundSessionEvents Events(this global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession item) => new PrintWorkflowBackgroundSessionEvents(item); + public static RxPrintWorkflowBackgroundSessionEvents Events(this global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession item) => new RxPrintWorkflowBackgroundSessionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PrintWorkflowForegroundSessionEvents Events(this global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession item) => new PrintWorkflowForegroundSessionEvents(item); + public static RxPrintWorkflowForegroundSessionEvents Events(this global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession item) => new RxPrintWorkflowForegroundSessionEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class PrintWorkflowBackgroundSessionEvents + public class RxPrintWorkflowBackgroundSessionEvents { private readonly global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PrintWorkflowBackgroundSessionEvents(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession data) + public RxPrintWorkflowBackgroundSessionEvents(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args)> SetupRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args)> Submitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args)>(eventHandler => { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Submitted += x, x => _data.Submitted -= x); + }, x => _data.Submitted += x, x => _data.Submitted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PrintWorkflowForegroundSessionEvents + public class RxPrintWorkflowForegroundSessionEvents { private readonly global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PrintWorkflowForegroundSessionEvents(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession data) + public RxPrintWorkflowForegroundSessionEvents(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args)> SetupRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args)> XpsDataAvailable => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args)>(eventHandler => { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.XpsDataAvailable += x, x => _data.XpsDataAvailable -= x); + }, x => _data.XpsDataAvailable += x, x => _data.XpsDataAvailable -= x); } } @@ -7297,34 +6651,32 @@ namespace Windows.Management.Policies /// /// A wrapper class which wraps all the events contained within the class. /// - public static NamedPolicyDataEvents Events(this global::Windows.Management.Policies.NamedPolicyData item) => new NamedPolicyDataEvents(item); + public static RxNamedPolicyDataEvents Events(this global::Windows.Management.Policies.NamedPolicyData item) => new RxNamedPolicyDataEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class NamedPolicyDataEvents + public class RxNamedPolicyDataEvents { private readonly global::Windows.Management.Policies.NamedPolicyData _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public NamedPolicyDataEvents(global::Windows.Management.Policies.NamedPolicyData data) + public RxNamedPolicyDataEvents(global::Windows.Management.Policies.NamedPolicyData data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Management.Policies.NamedPolicyData sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Management.Policies.NamedPolicyData sender, object args)>(eventHandler => { void Handler(global::Windows.Management.Policies.NamedPolicyData sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } } @@ -7338,145 +6690,125 @@ namespace Windows.Media /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaTimelineControllerEvents Events(this global::Windows.Media.MediaTimelineController item) => new MediaTimelineControllerEvents(item); + public static RxMediaTimelineControllerEvents Events(this global::Windows.Media.MediaTimelineController item) => new RxMediaTimelineControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SystemMediaTransportControlsEvents Events(this global::Windows.Media.SystemMediaTransportControls item) => new SystemMediaTransportControlsEvents(item); + public static RxSystemMediaTransportControlsEvents Events(this global::Windows.Media.SystemMediaTransportControls item) => new RxSystemMediaTransportControlsEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaTimelineControllerEvents + public class RxMediaTimelineControllerEvents { private readonly global::Windows.Media.MediaTimelineController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaTimelineControllerEvents(global::Windows.Media.MediaTimelineController data) + public RxMediaTimelineControllerEvents(global::Windows.Media.MediaTimelineController data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, object args)> Ended => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, object args)>(eventHandler => { void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Ended += x, x => _data.Ended -= x); + }, x => _data.Ended += x, x => _data.Ended -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args)> Failed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Failed += x, x => _data.Failed -= x); + }, x => _data.Failed += x, x => _data.Failed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, object args)> PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, object args)>(eventHandler => { void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.MediaTimelineController sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.MediaTimelineController sender, object args)>(eventHandler => { void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SystemMediaTransportControlsEvents + public class RxSystemMediaTransportControlsEvents { private readonly global::Windows.Media.SystemMediaTransportControls _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SystemMediaTransportControlsEvents(global::Windows.Media.SystemMediaTransportControls data) + public RxSystemMediaTransportControlsEvents(global::Windows.Media.SystemMediaTransportControls data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args)> AutoRepeatModeChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutoRepeatModeChangeRequested += x, x => _data.AutoRepeatModeChangeRequested -= x); + }, x => _data.AutoRepeatModeChangeRequested += x, x => _data.AutoRepeatModeChangeRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args)> ButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args)> PlaybackPositionChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackPositionChangeRequested += x, x => _data.PlaybackPositionChangeRequested -= x); + }, x => _data.PlaybackPositionChangeRequested += x, x => _data.PlaybackPositionChangeRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args)> PlaybackRateChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args)> PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args)> ShuffleEnabledChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShuffleEnabledChangeRequested += x, x => _data.ShuffleEnabledChangeRequested -= x); + }, x => _data.ShuffleEnabledChangeRequested += x, x => _data.ShuffleEnabledChangeRequested -= x); } } @@ -7490,219 +6822,201 @@ namespace Windows.Media.Audio /// /// A wrapper class which wraps all the events contained within the class. /// - public static AudioFileInputNodeEvents Events(this global::Windows.Media.Audio.AudioFileInputNode item) => new AudioFileInputNodeEvents(item); + public static RxAudioFileInputNodeEvents Events(this global::Windows.Media.Audio.AudioFileInputNode item) => new RxAudioFileInputNodeEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AudioFrameInputNodeEvents Events(this global::Windows.Media.Audio.AudioFrameInputNode item) => new AudioFrameInputNodeEvents(item); + public static RxAudioFrameInputNodeEvents Events(this global::Windows.Media.Audio.AudioFrameInputNode item) => new RxAudioFrameInputNodeEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AudioGraphEvents Events(this global::Windows.Media.Audio.AudioGraph item) => new AudioGraphEvents(item); + public static RxAudioGraphEvents Events(this global::Windows.Media.Audio.AudioGraph item) => new RxAudioGraphEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AudioStateMonitorEvents Events(this global::Windows.Media.Audio.AudioStateMonitor item) => new AudioStateMonitorEvents(item); + public static RxAudioStateMonitorEvents Events(this global::Windows.Media.Audio.AudioStateMonitor item) => new RxAudioStateMonitorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaSourceAudioInputNodeEvents Events(this global::Windows.Media.Audio.MediaSourceAudioInputNode item) => new MediaSourceAudioInputNodeEvents(item); + public static RxMediaSourceAudioInputNodeEvents Events(this global::Windows.Media.Audio.MediaSourceAudioInputNode item) => new RxMediaSourceAudioInputNodeEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SpatialAudioDeviceConfigurationEvents Events(this global::Windows.Media.Audio.SpatialAudioDeviceConfiguration item) => new SpatialAudioDeviceConfigurationEvents(item); + public static RxSpatialAudioDeviceConfigurationEvents Events(this global::Windows.Media.Audio.SpatialAudioDeviceConfiguration item) => new RxSpatialAudioDeviceConfigurationEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AudioFileInputNodeEvents + public class RxAudioFileInputNodeEvents { private readonly global::Windows.Media.Audio.AudioFileInputNode _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AudioFileInputNodeEvents(global::Windows.Media.Audio.AudioFileInputNode data) + public RxAudioFileInputNodeEvents(global::Windows.Media.Audio.AudioFileInputNode data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Audio.AudioFileInputNode sender, object args)> FileCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioFileInputNode sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Audio.AudioFileInputNode sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileCompleted += x, x => _data.FileCompleted -= x); + }, x => _data.FileCompleted += x, x => _data.FileCompleted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AudioFrameInputNodeEvents + public class RxAudioFrameInputNodeEvents { private readonly global::Windows.Media.Audio.AudioFrameInputNode _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AudioFrameInputNodeEvents(global::Windows.Media.Audio.AudioFrameInputNode data) + public RxAudioFrameInputNodeEvents(global::Windows.Media.Audio.AudioFrameInputNode data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args)> AudioFrameCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioFrameCompleted += x, x => _data.AudioFrameCompleted -= x); + }, x => _data.AudioFrameCompleted += x, x => _data.AudioFrameCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args)> QuantumStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AudioGraphEvents + public class RxAudioGraphEvents { private readonly global::Windows.Media.Audio.AudioGraph _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AudioGraphEvents(global::Windows.Media.Audio.AudioGraph data) + public RxAudioGraphEvents(global::Windows.Media.Audio.AudioGraph data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Audio.AudioGraph sender, object args)> QuantumProcessed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioGraph sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuantumProcessed += x, x => _data.QuantumProcessed -= x); + }, x => _data.QuantumProcessed += x, x => _data.QuantumProcessed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Audio.AudioGraph sender, object args)> QuantumStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioGraph sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args)> UnrecoverableErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnrecoverableErrorOccurred += x, x => _data.UnrecoverableErrorOccurred -= x); + }, x => _data.UnrecoverableErrorOccurred += x, x => _data.UnrecoverableErrorOccurred -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AudioStateMonitorEvents + public class RxAudioStateMonitorEvents { private readonly global::Windows.Media.Audio.AudioStateMonitor _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AudioStateMonitorEvents(global::Windows.Media.Audio.AudioStateMonitor data) + public RxAudioStateMonitorEvents(global::Windows.Media.Audio.AudioStateMonitor data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Audio.AudioStateMonitor sender, object args)> SoundLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.AudioStateMonitor sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Audio.AudioStateMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SoundLevelChanged += x, x => _data.SoundLevelChanged -= x); + }, x => _data.SoundLevelChanged += x, x => _data.SoundLevelChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaSourceAudioInputNodeEvents + public class RxMediaSourceAudioInputNodeEvents { private readonly global::Windows.Media.Audio.MediaSourceAudioInputNode _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaSourceAudioInputNodeEvents(global::Windows.Media.Audio.MediaSourceAudioInputNode data) + public RxMediaSourceAudioInputNodeEvents(global::Windows.Media.Audio.MediaSourceAudioInputNode data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args)> MediaSourceCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaSourceCompleted += x, x => _data.MediaSourceCompleted -= x); + }, x => _data.MediaSourceCompleted += x, x => _data.MediaSourceCompleted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SpatialAudioDeviceConfigurationEvents + public class RxSpatialAudioDeviceConfigurationEvents { private readonly global::Windows.Media.Audio.SpatialAudioDeviceConfiguration _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SpatialAudioDeviceConfigurationEvents(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration data) + public RxSpatialAudioDeviceConfigurationEvents(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args)> ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } } @@ -7716,228 +7030,204 @@ namespace Windows.Media.Capture /// /// A wrapper class which wraps all the events contained within the class. /// - public static AdvancedPhotoCaptureEvents Events(this global::Windows.Media.Capture.AdvancedPhotoCapture item) => new AdvancedPhotoCaptureEvents(item); + public static RxAdvancedPhotoCaptureEvents Events(this global::Windows.Media.Capture.AdvancedPhotoCapture item) => new RxAdvancedPhotoCaptureEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AppCaptureEvents Events(this global::Windows.Media.Capture.AppCapture item) => new AppCaptureEvents(item); + public static RxAppCaptureEvents Events(this global::Windows.Media.Capture.AppCapture item) => new RxAppCaptureEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static LowLagPhotoSequenceCaptureEvents Events(this global::Windows.Media.Capture.LowLagPhotoSequenceCapture item) => new LowLagPhotoSequenceCaptureEvents(item); + public static RxLowLagPhotoSequenceCaptureEvents Events(this global::Windows.Media.Capture.LowLagPhotoSequenceCapture item) => new RxLowLagPhotoSequenceCaptureEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaCaptureEvents Events(this global::Windows.Media.Capture.MediaCapture item) => new MediaCaptureEvents(item); + public static RxMediaCaptureEvents Events(this global::Windows.Media.Capture.MediaCapture item) => new RxMediaCaptureEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ScreenCaptureEvents Events(this global::Windows.Media.Capture.ScreenCapture item) => new ScreenCaptureEvents(item); + public static RxScreenCaptureEvents Events(this global::Windows.Media.Capture.ScreenCapture item) => new RxScreenCaptureEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AdvancedPhotoCaptureEvents + public class RxAdvancedPhotoCaptureEvents { private readonly global::Windows.Media.Capture.AdvancedPhotoCapture _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AdvancedPhotoCaptureEvents(global::Windows.Media.Capture.AdvancedPhotoCapture data) + public RxAdvancedPhotoCaptureEvents(global::Windows.Media.Capture.AdvancedPhotoCapture data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args)> AllPhotosCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AllPhotosCaptured += x, x => _data.AllPhotosCaptured -= x); + }, x => _data.AllPhotosCaptured += x, x => _data.AllPhotosCaptured -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args)> OptionalReferencePhotoCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionalReferencePhotoCaptured += x, x => _data.OptionalReferencePhotoCaptured -= x); + }, x => _data.OptionalReferencePhotoCaptured += x, x => _data.OptionalReferencePhotoCaptured -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AppCaptureEvents + public class RxAppCaptureEvents { private readonly global::Windows.Media.Capture.AppCapture _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AppCaptureEvents(global::Windows.Media.Capture.AppCapture data) + public RxAppCaptureEvents(global::Windows.Media.Capture.AppCapture data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.AppCapture sender, object args)> CapturingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.AppCapture sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Capture.AppCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CapturingChanged += x, x => _data.CapturingChanged -= x); + }, x => _data.CapturingChanged += x, x => _data.CapturingChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class LowLagPhotoSequenceCaptureEvents + public class RxLowLagPhotoSequenceCaptureEvents { private readonly global::Windows.Media.Capture.LowLagPhotoSequenceCapture _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public LowLagPhotoSequenceCaptureEvents(global::Windows.Media.Capture.LowLagPhotoSequenceCapture data) + public RxLowLagPhotoSequenceCaptureEvents(global::Windows.Media.Capture.LowLagPhotoSequenceCapture data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args)> PhotoCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaCaptureEvents + public class RxMediaCaptureEvents { private readonly global::Windows.Media.Capture.MediaCapture _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaCaptureEvents(global::Windows.Media.Capture.MediaCapture data) + public RxMediaCaptureEvents(global::Windows.Media.Capture.MediaCapture data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, object args)> CameraStreamStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraStreamStateChanged += x, x => _data.CameraStreamStateChanged -= x); + }, x => _data.CameraStreamStateChanged += x, x => _data.CameraStreamStateChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args)> CaptureDeviceExclusiveControlStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CaptureDeviceExclusiveControlStatusChanged += x, x => _data.CaptureDeviceExclusiveControlStatusChanged -= x); + }, x => _data.CaptureDeviceExclusiveControlStatusChanged += x, x => _data.CaptureDeviceExclusiveControlStatusChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFailedEventArgs errorEventArgs)> Failed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFailedEventArgs errorEventArgs) => eventHandler((sender, errorEventArgs)); return Handler; - } - - , x => _data.Failed += x, x => _data.Failed -= x); + }, x => _data.Failed += x, x => _data.Failed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args)> FocusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusChanged += x, x => _data.FocusChanged -= x); + }, x => _data.FocusChanged += x, x => _data.FocusChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args)> PhotoConfirmationCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PhotoConfirmationCaptured += x, x => _data.PhotoConfirmationCaptured -= x); + }, x => _data.PhotoConfirmationCaptured += x, x => _data.PhotoConfirmationCaptured -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable RecordLimitationExceeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(global::Windows.Media.Capture.MediaCapture sender) => eventHandler(sender); return Handler; - } - - , x => _data.RecordLimitationExceeded += x, x => _data.RecordLimitationExceeded -= x); + }, x => _data.RecordLimitationExceeded += x, x => _data.RecordLimitationExceeded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.MediaCapture sender, object args)> ThermalStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.MediaCapture sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThermalStatusChanged += x, x => _data.ThermalStatusChanged -= x); + }, x => _data.ThermalStatusChanged += x, x => _data.ThermalStatusChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ScreenCaptureEvents + public class RxScreenCaptureEvents { private readonly global::Windows.Media.Capture.ScreenCapture _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ScreenCaptureEvents(global::Windows.Media.Capture.ScreenCapture data) + public RxScreenCaptureEvents(global::Windows.Media.Capture.ScreenCapture data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args)> SourceSuspensionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceSuspensionChanged += x, x => _data.SourceSuspensionChanged -= x); + }, x => _data.SourceSuspensionChanged += x, x => _data.SourceSuspensionChanged -= x); } } @@ -7951,44 +7241,40 @@ namespace Windows.Media.Capture.Core /// /// A wrapper class which wraps all the events contained within the class. /// - public static VariablePhotoSequenceCaptureEvents Events(this global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture item) => new VariablePhotoSequenceCaptureEvents(item); + public static RxVariablePhotoSequenceCaptureEvents Events(this global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture item) => new RxVariablePhotoSequenceCaptureEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class VariablePhotoSequenceCaptureEvents + public class RxVariablePhotoSequenceCaptureEvents { private readonly global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public VariablePhotoSequenceCaptureEvents(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture data) + public RxVariablePhotoSequenceCaptureEvents(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args)> PhotoCaptured => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -8002,96 +7288,90 @@ namespace Windows.Media.Capture.Frames /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaFrameReaderEvents Events(this global::Windows.Media.Capture.Frames.MediaFrameReader item) => new MediaFrameReaderEvents(item); + public static RxMediaFrameReaderEvents Events(this global::Windows.Media.Capture.Frames.MediaFrameReader item) => new RxMediaFrameReaderEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaFrameSourceEvents Events(this global::Windows.Media.Capture.Frames.MediaFrameSource item) => new MediaFrameSourceEvents(item); + public static RxMediaFrameSourceEvents Events(this global::Windows.Media.Capture.Frames.MediaFrameSource item) => new RxMediaFrameSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MultiSourceMediaFrameReaderEvents Events(this global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader item) => new MultiSourceMediaFrameReaderEvents(item); + public static RxMultiSourceMediaFrameReaderEvents Events(this global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader item) => new RxMultiSourceMediaFrameReaderEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaFrameReaderEvents + public class RxMediaFrameReaderEvents { private readonly global::Windows.Media.Capture.Frames.MediaFrameReader _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaFrameReaderEvents(global::Windows.Media.Capture.Frames.MediaFrameReader data) + public RxMediaFrameReaderEvents(global::Windows.Media.Capture.Frames.MediaFrameReader data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaFrameSourceEvents + public class RxMediaFrameSourceEvents { private readonly global::Windows.Media.Capture.Frames.MediaFrameSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaFrameSourceEvents(global::Windows.Media.Capture.Frames.MediaFrameSource data) + public RxMediaFrameSourceEvents(global::Windows.Media.Capture.Frames.MediaFrameSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args)> FormatChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MultiSourceMediaFrameReaderEvents + public class RxMultiSourceMediaFrameReaderEvents { private readonly global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MultiSourceMediaFrameReaderEvents(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader data) + public RxMultiSourceMediaFrameReaderEvents(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args)> FrameArrived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } } @@ -8105,85 +7385,77 @@ namespace Windows.Media.Casting /// /// A wrapper class which wraps all the events contained within the class. /// - public static CastingConnectionEvents Events(this global::Windows.Media.Casting.CastingConnection item) => new CastingConnectionEvents(item); + public static RxCastingConnectionEvents Events(this global::Windows.Media.Casting.CastingConnection item) => new RxCastingConnectionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CastingDevicePickerEvents Events(this global::Windows.Media.Casting.CastingDevicePicker item) => new CastingDevicePickerEvents(item); + public static RxCastingDevicePickerEvents Events(this global::Windows.Media.Casting.CastingDevicePicker item) => new RxCastingDevicePickerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class CastingConnectionEvents + public class RxCastingConnectionEvents { private readonly global::Windows.Media.Casting.CastingConnection _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CastingConnectionEvents(global::Windows.Media.Casting.CastingConnection data) + public RxCastingConnectionEvents(global::Windows.Media.Casting.CastingConnection data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Casting.CastingConnection sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingConnection sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Casting.CastingConnection sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CastingDevicePickerEvents + public class RxCastingDevicePickerEvents { private readonly global::Windows.Media.Casting.CastingDevicePicker _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CastingDevicePickerEvents(global::Windows.Media.Casting.CastingDevicePicker data) + public RxCastingDevicePickerEvents(global::Windows.Media.Casting.CastingDevicePicker data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Casting.CastingDevicePicker sender, object args)> CastingDevicePickerDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingDevicePicker sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CastingDevicePickerDismissed += x, x => _data.CastingDevicePickerDismissed -= x); + }, x => _data.CastingDevicePickerDismissed += x, x => _data.CastingDevicePickerDismissed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args)> CastingDeviceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CastingDeviceSelected += x, x => _data.CastingDeviceSelected -= x); + }, x => _data.CastingDeviceSelected += x, x => _data.CastingDeviceSelected -= x); } } @@ -8197,34 +7469,32 @@ namespace Windows.Media.ContentRestrictions /// /// A wrapper class which wraps all the events contained within the class. /// - public static RatedContentRestrictionsEvents Events(this global::Windows.Media.ContentRestrictions.RatedContentRestrictions item) => new RatedContentRestrictionsEvents(item); + public static RxRatedContentRestrictionsEvents Events(this global::Windows.Media.ContentRestrictions.RatedContentRestrictions item) => new RxRatedContentRestrictionsEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class RatedContentRestrictionsEvents + public class RxRatedContentRestrictionsEvents { private readonly global::Windows.Media.ContentRestrictions.RatedContentRestrictions _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RatedContentRestrictionsEvents(global::Windows.Media.ContentRestrictions.RatedContentRestrictions data) + public RxRatedContentRestrictionsEvents(global::Windows.Media.ContentRestrictions.RatedContentRestrictions data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable RestrictionsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.RestrictionsChanged += x, x => _data.RestrictionsChanged -= x); + }, x => _data.RestrictionsChanged += x, x => _data.RestrictionsChanged -= x); } } @@ -8238,95 +7508,85 @@ namespace Windows.Media.Control /// /// A wrapper class which wraps all the events contained within the class. /// - public static GlobalSystemMediaTransportControlsSessionEvents Events(this global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession item) => new GlobalSystemMediaTransportControlsSessionEvents(item); + public static RxGlobalSystemMediaTransportControlsSessionEvents Events(this global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession item) => new RxGlobalSystemMediaTransportControlsSessionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GlobalSystemMediaTransportControlsSessionManagerEvents Events(this global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager item) => new GlobalSystemMediaTransportControlsSessionManagerEvents(item); + public static RxGlobalSystemMediaTransportControlsSessionManagerEvents Events(this global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager item) => new RxGlobalSystemMediaTransportControlsSessionManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class GlobalSystemMediaTransportControlsSessionEvents + public class RxGlobalSystemMediaTransportControlsSessionEvents { private readonly global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GlobalSystemMediaTransportControlsSessionEvents(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession data) + public RxGlobalSystemMediaTransportControlsSessionEvents(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args)> MediaPropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaPropertiesChanged += x, x => _data.MediaPropertiesChanged -= x); + }, x => _data.MediaPropertiesChanged += x, x => _data.MediaPropertiesChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args)> PlaybackInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackInfoChanged += x, x => _data.PlaybackInfoChanged -= x); + }, x => _data.PlaybackInfoChanged += x, x => _data.PlaybackInfoChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args)> TimelinePropertiesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimelinePropertiesChanged += x, x => _data.TimelinePropertiesChanged -= x); + }, x => _data.TimelinePropertiesChanged += x, x => _data.TimelinePropertiesChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GlobalSystemMediaTransportControlsSessionManagerEvents + public class RxGlobalSystemMediaTransportControlsSessionManagerEvents { private readonly global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GlobalSystemMediaTransportControlsSessionManagerEvents(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager data) + public RxGlobalSystemMediaTransportControlsSessionManagerEvents(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args)> CurrentSessionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentSessionChanged += x, x => _data.CurrentSessionChanged -= x); + }, x => _data.CurrentSessionChanged += x, x => _data.CurrentSessionChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args)> SessionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionsChanged += x, x => _data.SessionsChanged -= x); + }, x => _data.SessionsChanged += x, x => _data.SessionsChanged -= x); } } @@ -8340,680 +7600,616 @@ namespace Windows.Media.Core /// /// A wrapper class which wraps all the events contained within the class. /// - public static AudioTrackEvents Events(this global::Windows.Media.Core.AudioTrack item) => new AudioTrackEvents(item); + public static RxAudioTrackEvents Events(this global::Windows.Media.Core.AudioTrack item) => new RxAudioTrackEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static FaceDetectionEffectEvents Events(this global::Windows.Media.Core.FaceDetectionEffect item) => new FaceDetectionEffectEvents(item); + public static RxFaceDetectionEffectEvents Events(this global::Windows.Media.Core.FaceDetectionEffect item) => new RxFaceDetectionEffectEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ISingleSelectMediaTrackListEvents Events(this global::Windows.Media.Core.ISingleSelectMediaTrackList item) => new ISingleSelectMediaTrackListEvents(item); + public static RxISingleSelectMediaTrackListEvents Events(this global::Windows.Media.Core.ISingleSelectMediaTrackList item) => new RxISingleSelectMediaTrackListEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaBinderEvents Events(this global::Windows.Media.Core.MediaBinder item) => new MediaBinderEvents(item); + public static RxMediaBinderEvents Events(this global::Windows.Media.Core.MediaBinder item) => new RxMediaBinderEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaBindingEventArgsEvents Events(this global::Windows.Media.Core.MediaBindingEventArgs item) => new MediaBindingEventArgsEvents(item); + public static RxMediaBindingEventArgsEvents Events(this global::Windows.Media.Core.MediaBindingEventArgs item) => new RxMediaBindingEventArgsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaSourceEvents Events(this global::Windows.Media.Core.MediaSource item) => new MediaSourceEvents(item); + public static RxMediaSourceEvents Events(this global::Windows.Media.Core.MediaSource item) => new RxMediaSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaSourceAppServiceConnectionEvents Events(this global::Windows.Media.Core.MediaSourceAppServiceConnection item) => new MediaSourceAppServiceConnectionEvents(item); + public static RxMediaSourceAppServiceConnectionEvents Events(this global::Windows.Media.Core.MediaSourceAppServiceConnection item) => new RxMediaSourceAppServiceConnectionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaStreamSampleEvents Events(this global::Windows.Media.Core.MediaStreamSample item) => new MediaStreamSampleEvents(item); + public static RxMediaStreamSampleEvents Events(this global::Windows.Media.Core.MediaStreamSample item) => new RxMediaStreamSampleEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaStreamSourceEvents Events(this global::Windows.Media.Core.MediaStreamSource item) => new MediaStreamSourceEvents(item); + public static RxMediaStreamSourceEvents Events(this global::Windows.Media.Core.MediaStreamSource item) => new RxMediaStreamSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MseSourceBufferEvents Events(this global::Windows.Media.Core.MseSourceBuffer item) => new MseSourceBufferEvents(item); + public static RxMseSourceBufferEvents Events(this global::Windows.Media.Core.MseSourceBuffer item) => new RxMseSourceBufferEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MseSourceBufferListEvents Events(this global::Windows.Media.Core.MseSourceBufferList item) => new MseSourceBufferListEvents(item); + public static RxMseSourceBufferListEvents Events(this global::Windows.Media.Core.MseSourceBufferList item) => new RxMseSourceBufferListEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MseStreamSourceEvents Events(this global::Windows.Media.Core.MseStreamSource item) => new MseStreamSourceEvents(item); + public static RxMseStreamSourceEvents Events(this global::Windows.Media.Core.MseStreamSource item) => new RxMseStreamSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SceneAnalysisEffectEvents Events(this global::Windows.Media.Core.SceneAnalysisEffect item) => new SceneAnalysisEffectEvents(item); + public static RxSceneAnalysisEffectEvents Events(this global::Windows.Media.Core.SceneAnalysisEffect item) => new RxSceneAnalysisEffectEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TimedMetadataTrackEvents Events(this global::Windows.Media.Core.TimedMetadataTrack item) => new TimedMetadataTrackEvents(item); + public static RxTimedMetadataTrackEvents Events(this global::Windows.Media.Core.TimedMetadataTrack item) => new RxTimedMetadataTrackEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TimedTextSourceEvents Events(this global::Windows.Media.Core.TimedTextSource item) => new TimedTextSourceEvents(item); + public static RxTimedTextSourceEvents Events(this global::Windows.Media.Core.TimedTextSource item) => new RxTimedTextSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static VideoStabilizationEffectEvents Events(this global::Windows.Media.Core.VideoStabilizationEffect item) => new VideoStabilizationEffectEvents(item); + public static RxVideoStabilizationEffectEvents Events(this global::Windows.Media.Core.VideoStabilizationEffect item) => new RxVideoStabilizationEffectEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static VideoTrackEvents Events(this global::Windows.Media.Core.VideoTrack item) => new VideoTrackEvents(item); + public static RxVideoTrackEvents Events(this global::Windows.Media.Core.VideoTrack item) => new RxVideoTrackEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AudioTrackEvents + public class RxAudioTrackEvents { private readonly global::Windows.Media.Core.AudioTrack _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AudioTrackEvents(global::Windows.Media.Core.AudioTrack data) + public RxAudioTrackEvents(global::Windows.Media.Core.AudioTrack data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args)> OpenFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class FaceDetectionEffectEvents + public class RxFaceDetectionEffectEvents { private readonly global::Windows.Media.Core.FaceDetectionEffect _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public FaceDetectionEffectEvents(global::Windows.Media.Core.FaceDetectionEffect data) + public RxFaceDetectionEffectEvents(global::Windows.Media.Core.FaceDetectionEffect data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args)> FaceDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FaceDetected += x, x => _data.FaceDetected -= x); + }, x => _data.FaceDetected += x, x => _data.FaceDetected -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ISingleSelectMediaTrackListEvents + public class RxISingleSelectMediaTrackListEvents { private readonly global::Windows.Media.Core.ISingleSelectMediaTrackList _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ISingleSelectMediaTrackListEvents(global::Windows.Media.Core.ISingleSelectMediaTrackList data) + public RxISingleSelectMediaTrackListEvents(global::Windows.Media.Core.ISingleSelectMediaTrackList data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)> SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaBinderEvents + public class RxMediaBinderEvents { private readonly global::Windows.Media.Core.MediaBinder _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaBinderEvents(global::Windows.Media.Core.MediaBinder data) + public RxMediaBinderEvents(global::Windows.Media.Core.MediaBinder data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args)> Binding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Binding += x, x => _data.Binding -= x); + }, x => _data.Binding += x, x => _data.Binding -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaBindingEventArgsEvents + public class RxMediaBindingEventArgsEvents { private readonly global::Windows.Media.Core.MediaBindingEventArgs _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaBindingEventArgsEvents(global::Windows.Media.Core.MediaBindingEventArgs data) + public RxMediaBindingEventArgsEvents(global::Windows.Media.Core.MediaBindingEventArgs data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MediaBindingEventArgs sender, object args)> Canceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaBindingEventArgs sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.MediaBindingEventArgs sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaSourceEvents + public class RxMediaSourceEvents { private readonly global::Windows.Media.Core.MediaSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaSourceEvents(global::Windows.Media.Core.MediaSource data) + public RxMediaSourceEvents(global::Windows.Media.Core.MediaSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args)> OpenOperationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenOperationCompleted += x, x => _data.OpenOperationCompleted -= x); + }, x => _data.OpenOperationCompleted += x, x => _data.OpenOperationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaSourceAppServiceConnectionEvents + public class RxMediaSourceAppServiceConnectionEvents { private readonly global::Windows.Media.Core.MediaSourceAppServiceConnection _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaSourceAppServiceConnectionEvents(global::Windows.Media.Core.MediaSourceAppServiceConnection data) + public RxMediaSourceAppServiceConnectionEvents(global::Windows.Media.Core.MediaSourceAppServiceConnection data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args)> InitializeMediaStreamSourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InitializeMediaStreamSourceRequested += x, x => _data.InitializeMediaStreamSourceRequested -= x); + }, x => _data.InitializeMediaStreamSourceRequested += x, x => _data.InitializeMediaStreamSourceRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaStreamSampleEvents + public class RxMediaStreamSampleEvents { private readonly global::Windows.Media.Core.MediaStreamSample _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaStreamSampleEvents(global::Windows.Media.Core.MediaStreamSample data) + public RxMediaStreamSampleEvents(global::Windows.Media.Core.MediaStreamSample data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSample sender, object args)> Processed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSample sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.MediaStreamSample sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Processed += x, x => _data.Processed -= x); + }, x => _data.Processed += x, x => _data.Processed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaStreamSourceEvents + public class RxMediaStreamSourceEvents { private readonly global::Windows.Media.Core.MediaStreamSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaStreamSourceEvents(global::Windows.Media.Core.MediaStreamSource data) + public RxMediaStreamSourceEvents(global::Windows.Media.Core.MediaStreamSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, object args)> Paused => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.MediaStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Paused += x, x => _data.Paused -= x); + }, x => _data.Paused += x, x => _data.Paused -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args)> SampleRendered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SampleRendered += x, x => _data.SampleRendered -= x); + }, x => _data.SampleRendered += x, x => _data.SampleRendered -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args)> SampleRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SampleRequested += x, x => _data.SampleRequested -= x); + }, x => _data.SampleRequested += x, x => _data.SampleRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args)> Starting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Starting += x, x => _data.Starting -= x); + }, x => _data.Starting += x, x => _data.Starting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args)> SwitchStreamsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SwitchStreamsRequested += x, x => _data.SwitchStreamsRequested -= x); + }, x => _data.SwitchStreamsRequested += x, x => _data.SwitchStreamsRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MseSourceBufferEvents + public class RxMseSourceBufferEvents { private readonly global::Windows.Media.Core.MseSourceBuffer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MseSourceBufferEvents(global::Windows.Media.Core.MseSourceBuffer data) + public RxMseSourceBufferEvents(global::Windows.Media.Core.MseSourceBuffer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> Aborted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Aborted += x, x => _data.Aborted -= x); + }, x => _data.Aborted += x, x => _data.Aborted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> UpdateEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateEnded += x, x => _data.UpdateEnded -= x); + }, x => _data.UpdateEnded += x, x => _data.UpdateEnded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MseSourceBuffer sender, object args)> UpdateStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBuffer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateStarting += x, x => _data.UpdateStarting -= x); + }, x => _data.UpdateStarting += x, x => _data.UpdateStarting -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MseSourceBufferListEvents + public class RxMseSourceBufferListEvents { private readonly global::Windows.Media.Core.MseSourceBufferList _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MseSourceBufferListEvents(global::Windows.Media.Core.MseSourceBufferList data) + public RxMseSourceBufferListEvents(global::Windows.Media.Core.MseSourceBufferList data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MseSourceBufferList sender, object args)> SourceBufferAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBufferList sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceBufferAdded += x, x => _data.SourceBufferAdded -= x); + }, x => _data.SourceBufferAdded += x, x => _data.SourceBufferAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MseSourceBufferList sender, object args)> SourceBufferRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseSourceBufferList sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceBufferRemoved += x, x => _data.SourceBufferRemoved -= x); + }, x => _data.SourceBufferRemoved += x, x => _data.SourceBufferRemoved -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MseStreamSourceEvents + public class RxMseStreamSourceEvents { private readonly global::Windows.Media.Core.MseStreamSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MseStreamSourceEvents(global::Windows.Media.Core.MseStreamSource data) + public RxMseStreamSourceEvents(global::Windows.Media.Core.MseStreamSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MseStreamSource sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseStreamSource sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MseStreamSource sender, object args)> Ended => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseStreamSource sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Ended += x, x => _data.Ended -= x); + }, x => _data.Ended += x, x => _data.Ended -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.MseStreamSource sender, object args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.MseStreamSource sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SceneAnalysisEffectEvents + public class RxSceneAnalysisEffectEvents { private readonly global::Windows.Media.Core.SceneAnalysisEffect _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SceneAnalysisEffectEvents(global::Windows.Media.Core.SceneAnalysisEffect data) + public RxSceneAnalysisEffectEvents(global::Windows.Media.Core.SceneAnalysisEffect data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args)> SceneAnalyzed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SceneAnalyzed += x, x => _data.SceneAnalyzed -= x); + }, x => _data.SceneAnalyzed += x, x => _data.SceneAnalyzed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TimedMetadataTrackEvents + public class RxTimedMetadataTrackEvents { private readonly global::Windows.Media.Core.TimedMetadataTrack _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TimedMetadataTrackEvents(global::Windows.Media.Core.TimedMetadataTrack data) + public RxTimedMetadataTrackEvents(global::Windows.Media.Core.TimedMetadataTrack data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)> CueEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CueEntered += x, x => _data.CueEntered -= x); + }, x => _data.CueEntered += x, x => _data.CueEntered -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)> CueExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CueExited += x, x => _data.CueExited -= x); + }, x => _data.CueExited += x, x => _data.CueExited -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args)> TrackFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TrackFailed += x, x => _data.TrackFailed -= x); + }, x => _data.TrackFailed += x, x => _data.TrackFailed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TimedTextSourceEvents + public class RxTimedTextSourceEvents { private readonly global::Windows.Media.Core.TimedTextSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TimedTextSourceEvents(global::Windows.Media.Core.TimedTextSource data) + public RxTimedTextSourceEvents(global::Windows.Media.Core.TimedTextSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args)> Resolved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Resolved += x, x => _data.Resolved -= x); + }, x => _data.Resolved += x, x => _data.Resolved -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class VideoStabilizationEffectEvents + public class RxVideoStabilizationEffectEvents { private readonly global::Windows.Media.Core.VideoStabilizationEffect _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public VideoStabilizationEffectEvents(global::Windows.Media.Core.VideoStabilizationEffect data) + public RxVideoStabilizationEffectEvents(global::Windows.Media.Core.VideoStabilizationEffect data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args)> EnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class VideoTrackEvents + public class RxVideoTrackEvents { private readonly global::Windows.Media.Core.VideoTrack _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public VideoTrackEvents(global::Windows.Media.Core.VideoTrack data) + public RxVideoTrackEvents(global::Windows.Media.Core.VideoTrack data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args)> OpenFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); } } @@ -9027,34 +8223,32 @@ namespace Windows.Media.Devices /// /// A wrapper class which wraps all the events contained within the class. /// - public static AudioDeviceModulesManagerEvents Events(this global::Windows.Media.Devices.AudioDeviceModulesManager item) => new AudioDeviceModulesManagerEvents(item); + public static RxAudioDeviceModulesManagerEvents Events(this global::Windows.Media.Devices.AudioDeviceModulesManager item) => new RxAudioDeviceModulesManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AudioDeviceModulesManagerEvents + public class RxAudioDeviceModulesManagerEvents { private readonly global::Windows.Media.Devices.AudioDeviceModulesManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AudioDeviceModulesManagerEvents(global::Windows.Media.Devices.AudioDeviceModulesManager data) + public RxAudioDeviceModulesManagerEvents(global::Windows.Media.Devices.AudioDeviceModulesManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args)> ModuleNotificationReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ModuleNotificationReceived += x, x => _data.ModuleNotificationReceived -= x); + }, x => _data.ModuleNotificationReceived += x, x => _data.ModuleNotificationReceived -= x); } } @@ -9068,54 +8262,48 @@ namespace Windows.Media.DialProtocol /// /// A wrapper class which wraps all the events contained within the class. /// - public static DialDevicePickerEvents Events(this global::Windows.Media.DialProtocol.DialDevicePicker item) => new DialDevicePickerEvents(item); + public static RxDialDevicePickerEvents Events(this global::Windows.Media.DialProtocol.DialDevicePicker item) => new RxDialDevicePickerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class DialDevicePickerEvents + public class RxDialDevicePickerEvents { private readonly global::Windows.Media.DialProtocol.DialDevicePicker _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DialDevicePickerEvents(global::Windows.Media.DialProtocol.DialDevicePicker data) + public RxDialDevicePickerEvents(global::Windows.Media.DialProtocol.DialDevicePicker data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.DialProtocol.DialDevicePicker sender, object args)> DialDevicePickerDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.DialProtocol.DialDevicePicker sender, object args)>(eventHandler => { void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DialDevicePickerDismissed += x, x => _data.DialDevicePickerDismissed -= x); + }, x => _data.DialDevicePickerDismissed += x, x => _data.DialDevicePickerDismissed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args)> DialDeviceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DialDeviceSelected += x, x => _data.DialDeviceSelected -= x); + }, x => _data.DialDeviceSelected += x, x => _data.DialDeviceSelected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args)> DisconnectButtonClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); } } @@ -9129,65 +8317,61 @@ namespace Windows.Media.Effects /// /// A wrapper class which wraps all the events contained within the class. /// - public static AudioCaptureEffectsManagerEvents Events(this global::Windows.Media.Effects.AudioCaptureEffectsManager item) => new AudioCaptureEffectsManagerEvents(item); + public static RxAudioCaptureEffectsManagerEvents Events(this global::Windows.Media.Effects.AudioCaptureEffectsManager item) => new RxAudioCaptureEffectsManagerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AudioRenderEffectsManagerEvents Events(this global::Windows.Media.Effects.AudioRenderEffectsManager item) => new AudioRenderEffectsManagerEvents(item); + public static RxAudioRenderEffectsManagerEvents Events(this global::Windows.Media.Effects.AudioRenderEffectsManager item) => new RxAudioRenderEffectsManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AudioCaptureEffectsManagerEvents + public class RxAudioCaptureEffectsManagerEvents { private readonly global::Windows.Media.Effects.AudioCaptureEffectsManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AudioCaptureEffectsManagerEvents(global::Windows.Media.Effects.AudioCaptureEffectsManager data) + public RxAudioCaptureEffectsManagerEvents(global::Windows.Media.Effects.AudioCaptureEffectsManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args)> AudioCaptureEffectsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioCaptureEffectsChanged += x, x => _data.AudioCaptureEffectsChanged -= x); + }, x => _data.AudioCaptureEffectsChanged += x, x => _data.AudioCaptureEffectsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AudioRenderEffectsManagerEvents + public class RxAudioRenderEffectsManagerEvents { private readonly global::Windows.Media.Effects.AudioRenderEffectsManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AudioRenderEffectsManagerEvents(global::Windows.Media.Effects.AudioRenderEffectsManager data) + public RxAudioRenderEffectsManagerEvents(global::Windows.Media.Effects.AudioRenderEffectsManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args)> AudioRenderEffectsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioRenderEffectsChanged += x, x => _data.AudioRenderEffectsChanged -= x); + }, x => _data.AudioRenderEffectsChanged += x, x => _data.AudioRenderEffectsChanged -= x); } } @@ -9201,44 +8385,40 @@ namespace Windows.Media.Import /// /// A wrapper class which wraps all the events contained within the class. /// - public static PhotoImportFindItemsResultEvents Events(this global::Windows.Media.Import.PhotoImportFindItemsResult item) => new PhotoImportFindItemsResultEvents(item); + public static RxPhotoImportFindItemsResultEvents Events(this global::Windows.Media.Import.PhotoImportFindItemsResult item) => new RxPhotoImportFindItemsResultEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class PhotoImportFindItemsResultEvents + public class RxPhotoImportFindItemsResultEvents { private readonly global::Windows.Media.Import.PhotoImportFindItemsResult _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PhotoImportFindItemsResultEvents(global::Windows.Media.Import.PhotoImportFindItemsResult data) + public RxPhotoImportFindItemsResultEvents(global::Windows.Media.Import.PhotoImportFindItemsResult data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args)> ItemImported => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemImported += x, x => _data.ItemImported -= x); + }, x => _data.ItemImported += x, x => _data.ItemImported -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args)> SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } } @@ -9252,764 +8432,658 @@ namespace Windows.Media.Playback /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaBreakManagerEvents Events(this global::Windows.Media.Playback.MediaBreakManager item) => new MediaBreakManagerEvents(item); + public static RxMediaBreakManagerEvents Events(this global::Windows.Media.Playback.MediaBreakManager item) => new RxMediaBreakManagerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaBreakScheduleEvents Events(this global::Windows.Media.Playback.MediaBreakSchedule item) => new MediaBreakScheduleEvents(item); + public static RxMediaBreakScheduleEvents Events(this global::Windows.Media.Playback.MediaBreakSchedule item) => new RxMediaBreakScheduleEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaPlaybackAudioTrackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackAudioTrackList item) => new MediaPlaybackAudioTrackListEvents(item); + public static RxMediaPlaybackAudioTrackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackAudioTrackList item) => new RxMediaPlaybackAudioTrackListEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaPlaybackCommandManagerEvents Events(this global::Windows.Media.Playback.MediaPlaybackCommandManager item) => new MediaPlaybackCommandManagerEvents(item); + public static RxMediaPlaybackCommandManagerEvents Events(this global::Windows.Media.Playback.MediaPlaybackCommandManager item) => new RxMediaPlaybackCommandManagerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaPlaybackCommandManagerCommandBehaviorEvents Events(this global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior item) => new MediaPlaybackCommandManagerCommandBehaviorEvents(item); + public static RxMediaPlaybackCommandManagerCommandBehaviorEvents Events(this global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior item) => new RxMediaPlaybackCommandManagerCommandBehaviorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaPlaybackItemEvents Events(this global::Windows.Media.Playback.MediaPlaybackItem item) => new MediaPlaybackItemEvents(item); + public static RxMediaPlaybackItemEvents Events(this global::Windows.Media.Playback.MediaPlaybackItem item) => new RxMediaPlaybackItemEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaPlaybackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackList item) => new MediaPlaybackListEvents(item); + public static RxMediaPlaybackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackList item) => new RxMediaPlaybackListEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaPlaybackSessionEvents Events(this global::Windows.Media.Playback.MediaPlaybackSession item) => new MediaPlaybackSessionEvents(item); + public static RxMediaPlaybackSessionEvents Events(this global::Windows.Media.Playback.MediaPlaybackSession item) => new RxMediaPlaybackSessionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaPlaybackTimedMetadataTrackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList item) => new MediaPlaybackTimedMetadataTrackListEvents(item); + public static RxMediaPlaybackTimedMetadataTrackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList item) => new RxMediaPlaybackTimedMetadataTrackListEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaPlaybackVideoTrackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackVideoTrackList item) => new MediaPlaybackVideoTrackListEvents(item); + public static RxMediaPlaybackVideoTrackListEvents Events(this global::Windows.Media.Playback.MediaPlaybackVideoTrackList item) => new RxMediaPlaybackVideoTrackListEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaPlayerEvents Events(this global::Windows.Media.Playback.MediaPlayer item) => new MediaPlayerEvents(item); + public static RxMediaPlayerEvents Events(this global::Windows.Media.Playback.MediaPlayer item) => new RxMediaPlayerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaBreakManagerEvents + public class RxMediaBreakManagerEvents { private readonly global::Windows.Media.Playback.MediaBreakManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaBreakManagerEvents(global::Windows.Media.Playback.MediaBreakManager data) + public RxMediaBreakManagerEvents(global::Windows.Media.Playback.MediaBreakManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args)> BreakEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreakEnded += x, x => _data.BreakEnded -= x); + }, x => _data.BreakEnded += x, x => _data.BreakEnded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args)> BreakSkipped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreakSkipped += x, x => _data.BreakSkipped -= x); + }, x => _data.BreakSkipped += x, x => _data.BreakSkipped -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args)> BreaksSeekedOver => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreaksSeekedOver += x, x => _data.BreaksSeekedOver -= x); + }, x => _data.BreaksSeekedOver += x, x => _data.BreaksSeekedOver -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args)> BreakStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreakStarted += x, x => _data.BreakStarted -= x); + }, x => _data.BreakStarted += x, x => _data.BreakStarted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaBreakScheduleEvents + public class RxMediaBreakScheduleEvents { private readonly global::Windows.Media.Playback.MediaBreakSchedule _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaBreakScheduleEvents(global::Windows.Media.Playback.MediaBreakSchedule data) + public RxMediaBreakScheduleEvents(global::Windows.Media.Playback.MediaBreakSchedule data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaBreakSchedule sender, object args)> ScheduleChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaBreakSchedule sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaBreakSchedule sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScheduleChanged += x, x => _data.ScheduleChanged -= x); + }, x => _data.ScheduleChanged += x, x => _data.ScheduleChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaPlaybackAudioTrackListEvents + public class RxMediaPlaybackAudioTrackListEvents { private readonly global::Windows.Media.Playback.MediaPlaybackAudioTrackList _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaPlaybackAudioTrackListEvents(global::Windows.Media.Playback.MediaPlaybackAudioTrackList data) + public RxMediaPlaybackAudioTrackListEvents(global::Windows.Media.Playback.MediaPlaybackAudioTrackList data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)> SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaPlaybackCommandManagerEvents + public class RxMediaPlaybackCommandManagerEvents { private readonly global::Windows.Media.Playback.MediaPlaybackCommandManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaPlaybackCommandManagerEvents(global::Windows.Media.Playback.MediaPlaybackCommandManager data) + public RxMediaPlaybackCommandManagerEvents(global::Windows.Media.Playback.MediaPlaybackCommandManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args)> AutoRepeatModeReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutoRepeatModeReceived += x, x => _data.AutoRepeatModeReceived -= x); + }, x => _data.AutoRepeatModeReceived += x, x => _data.AutoRepeatModeReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args)> FastForwardReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FastForwardReceived += x, x => _data.FastForwardReceived -= x); + }, x => _data.FastForwardReceived += x, x => _data.FastForwardReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args)> NextReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NextReceived += x, x => _data.NextReceived -= x); + }, x => _data.NextReceived += x, x => _data.NextReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args)> PauseReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PauseReceived += x, x => _data.PauseReceived -= x); + }, x => _data.PauseReceived += x, x => _data.PauseReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args)> PlayReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlayReceived += x, x => _data.PlayReceived -= x); + }, x => _data.PlayReceived += x, x => _data.PlayReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args)> PositionReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionReceived += x, x => _data.PositionReceived -= x); + }, x => _data.PositionReceived += x, x => _data.PositionReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args)> PreviousReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PreviousReceived += x, x => _data.PreviousReceived -= x); + }, x => _data.PreviousReceived += x, x => _data.PreviousReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args)> RateReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RateReceived += x, x => _data.RateReceived -= x); + }, x => _data.RateReceived += x, x => _data.RateReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args)> RewindReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RewindReceived += x, x => _data.RewindReceived -= x); + }, x => _data.RewindReceived += x, x => _data.RewindReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args)> ShuffleReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShuffleReceived += x, x => _data.ShuffleReceived -= x); + }, x => _data.ShuffleReceived += x, x => _data.ShuffleReceived -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaPlaybackCommandManagerCommandBehaviorEvents + public class RxMediaPlaybackCommandManagerCommandBehaviorEvents { private readonly global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaPlaybackCommandManagerCommandBehaviorEvents(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior data) + public RxMediaPlaybackCommandManagerCommandBehaviorEvents(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args)> IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaPlaybackItemEvents + public class RxMediaPlaybackItemEvents { private readonly global::Windows.Media.Playback.MediaPlaybackItem _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaPlaybackItemEvents(global::Windows.Media.Playback.MediaPlaybackItem data) + public RxMediaPlaybackItemEvents(global::Windows.Media.Playback.MediaPlaybackItem data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)> AudioTracksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioTracksChanged += x, x => _data.AudioTracksChanged -= x); + }, x => _data.AudioTracksChanged += x, x => _data.AudioTracksChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)> TimedMetadataTracksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimedMetadataTracksChanged += x, x => _data.TimedMetadataTracksChanged -= x); + }, x => _data.TimedMetadataTracksChanged += x, x => _data.TimedMetadataTracksChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)> VideoTracksChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoTracksChanged += x, x => _data.VideoTracksChanged -= x); + }, x => _data.VideoTracksChanged += x, x => _data.VideoTracksChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaPlaybackListEvents + public class RxMediaPlaybackListEvents { private readonly global::Windows.Media.Playback.MediaPlaybackList _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaPlaybackListEvents(global::Windows.Media.Playback.MediaPlaybackList data) + public RxMediaPlaybackListEvents(global::Windows.Media.Playback.MediaPlaybackList data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args)> CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args)> ItemFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemFailed += x, x => _data.ItemFailed -= x); + }, x => _data.ItemFailed += x, x => _data.ItemFailed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args)> ItemOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemOpened += x, x => _data.ItemOpened -= x); + }, x => _data.ItemOpened += x, x => _data.ItemOpened -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaPlaybackSessionEvents + public class RxMediaPlaybackSessionEvents { private readonly global::Windows.Media.Playback.MediaPlaybackSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaPlaybackSessionEvents(global::Windows.Media.Playback.MediaPlaybackSession data) + public RxMediaPlaybackSessionEvents(global::Windows.Media.Playback.MediaPlaybackSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferedRangesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferedRangesChanged += x, x => _data.BufferedRangesChanged -= x); + }, x => _data.BufferedRangesChanged += x, x => _data.BufferedRangesChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> DownloadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> NaturalDurationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NaturalDurationChanged += x, x => _data.NaturalDurationChanged -= x); + }, x => _data.NaturalDurationChanged += x, x => _data.NaturalDurationChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> NaturalVideoSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NaturalVideoSizeChanged += x, x => _data.NaturalVideoSizeChanged -= x); + }, x => _data.NaturalVideoSizeChanged += x, x => _data.NaturalVideoSizeChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PlaybackRateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackRateChanged += x, x => _data.PlaybackRateChanged -= x); + }, x => _data.PlaybackRateChanged += x, x => _data.PlaybackRateChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PlaybackStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackStateChanged += x, x => _data.PlaybackStateChanged -= x); + }, x => _data.PlaybackStateChanged += x, x => _data.PlaybackStateChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PlayedRangesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlayedRangesChanged += x, x => _data.PlayedRangesChanged -= x); + }, x => _data.PlayedRangesChanged += x, x => _data.PlayedRangesChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> SeekableRangesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeekableRangesChanged += x, x => _data.SeekableRangesChanged -= x); + }, x => _data.SeekableRangesChanged += x, x => _data.SeekableRangesChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> SeekCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackSession sender, object args)> SupportedPlaybackRatesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackSession sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SupportedPlaybackRatesChanged += x, x => _data.SupportedPlaybackRatesChanged -= x); + }, x => _data.SupportedPlaybackRatesChanged += x, x => _data.SupportedPlaybackRatesChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaPlaybackTimedMetadataTrackListEvents + public class RxMediaPlaybackTimedMetadataTrackListEvents { private readonly global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaPlaybackTimedMetadataTrackListEvents(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList data) + public RxMediaPlaybackTimedMetadataTrackListEvents(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args)> PresentationModeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PresentationModeChanged += x, x => _data.PresentationModeChanged -= x); + }, x => _data.PresentationModeChanged += x, x => _data.PresentationModeChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaPlaybackVideoTrackListEvents + public class RxMediaPlaybackVideoTrackListEvents { private readonly global::Windows.Media.Playback.MediaPlaybackVideoTrackList _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaPlaybackVideoTrackListEvents(global::Windows.Media.Playback.MediaPlaybackVideoTrackList data) + public RxMediaPlaybackVideoTrackListEvents(global::Windows.Media.Playback.MediaPlaybackVideoTrackList data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)> SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaPlayerEvents + public class RxMediaPlayerEvents { private readonly global::Windows.Media.Playback.MediaPlayer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaPlayerEvents(global::Windows.Media.Playback.MediaPlayer data) + public RxMediaPlayerEvents(global::Windows.Media.Playback.MediaPlayer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> BufferingEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> BufferingStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> IsMutedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsMutedChanged += x, x => _data.IsMutedChanged -= x); + }, x => _data.IsMutedChanged += x, x => _data.IsMutedChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> MediaEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args)> MediaFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> MediaOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args)> MediaPlayerRateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaPlayerRateChanged += x, x => _data.MediaPlayerRateChanged -= x); + }, x => _data.MediaPlayerRateChanged += x, x => _data.MediaPlayerRateChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args)> PlaybackMediaMarkerReached => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackMediaMarkerReached += x, x => _data.PlaybackMediaMarkerReached -= x); + }, x => _data.PlaybackMediaMarkerReached += x, x => _data.PlaybackMediaMarkerReached -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> SeekCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> SourceChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceChanged += x, x => _data.SourceChanged -= x); + }, x => _data.SourceChanged += x, x => _data.SourceChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> SubtitleFrameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SubtitleFrameChanged += x, x => _data.SubtitleFrameChanged -= x); + }, x => _data.SubtitleFrameChanged += x, x => _data.SubtitleFrameChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> VideoFrameAvailable => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoFrameAvailable += x, x => _data.VideoFrameAvailable -= x); + }, x => _data.VideoFrameAvailable += x, x => _data.VideoFrameAvailable -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Playback.MediaPlayer sender, object args)> VolumeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Playback.MediaPlayer sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); } } @@ -10023,206 +9097,178 @@ namespace Windows.Media.PlayTo /// /// A wrapper class which wraps all the events contained within the class. /// - public static PlayToConnectionEvents Events(this global::Windows.Media.PlayTo.PlayToConnection item) => new PlayToConnectionEvents(item); + public static RxPlayToConnectionEvents Events(this global::Windows.Media.PlayTo.PlayToConnection item) => new RxPlayToConnectionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PlayToManagerEvents Events(this global::Windows.Media.PlayTo.PlayToManager item) => new PlayToManagerEvents(item); + public static RxPlayToManagerEvents Events(this global::Windows.Media.PlayTo.PlayToManager item) => new RxPlayToManagerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PlayToReceiverEvents Events(this global::Windows.Media.PlayTo.PlayToReceiver item) => new PlayToReceiverEvents(item); + public static RxPlayToReceiverEvents Events(this global::Windows.Media.PlayTo.PlayToReceiver item) => new RxPlayToReceiverEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class PlayToConnectionEvents + public class RxPlayToConnectionEvents { private readonly global::Windows.Media.PlayTo.PlayToConnection _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PlayToConnectionEvents(global::Windows.Media.PlayTo.PlayToConnection data) + public RxPlayToConnectionEvents(global::Windows.Media.PlayTo.PlayToConnection data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args)> Error => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Error += x, x => _data.Error -= x); + }, x => _data.Error += x, x => _data.Error -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args)> Transferred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Transferred += x, x => _data.Transferred -= x); + }, x => _data.Transferred += x, x => _data.Transferred -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PlayToManagerEvents + public class RxPlayToManagerEvents { private readonly global::Windows.Media.PlayTo.PlayToManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PlayToManagerEvents(global::Windows.Media.PlayTo.PlayToManager data) + public RxPlayToManagerEvents(global::Windows.Media.PlayTo.PlayToManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args)> SourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRequested += x, x => _data.SourceRequested -= x); + }, x => _data.SourceRequested += x, x => _data.SourceRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args)> SourceSelected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceSelected += x, x => _data.SourceSelected -= x); + }, x => _data.SourceSelected += x, x => _data.SourceSelected -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PlayToReceiverEvents + public class RxPlayToReceiverEvents { private readonly global::Windows.Media.PlayTo.PlayToReceiver _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PlayToReceiverEvents(global::Windows.Media.PlayTo.PlayToReceiver data) + public RxPlayToReceiverEvents(global::Windows.Media.PlayTo.PlayToReceiver data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args)> CurrentTimeChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentTimeChangeRequested += x, x => _data.CurrentTimeChangeRequested -= x); + }, x => _data.CurrentTimeChangeRequested += x, x => _data.CurrentTimeChangeRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args)> MuteChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MuteChangeRequested += x, x => _data.MuteChangeRequested -= x); + }, x => _data.MuteChangeRequested += x, x => _data.MuteChangeRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> PauseRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PauseRequested += x, x => _data.PauseRequested -= x); + }, x => _data.PauseRequested += x, x => _data.PauseRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args)> PlaybackRateChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> PlayRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlayRequested += x, x => _data.PlayRequested -= x); + }, x => _data.PlayRequested += x, x => _data.PlayRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args)> SourceChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceChangeRequested += x, x => _data.SourceChangeRequested -= x); + }, x => _data.SourceChangeRequested += x, x => _data.SourceChangeRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> StopRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StopRequested += x, x => _data.StopRequested -= x); + }, x => _data.StopRequested += x, x => _data.StopRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, object args)> TimeUpdateRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, object args)>(eventHandler => { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimeUpdateRequested += x, x => _data.TimeUpdateRequested -= x); + }, x => _data.TimeUpdateRequested += x, x => _data.TimeUpdateRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args)> VolumeChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VolumeChangeRequested += x, x => _data.VolumeChangeRequested -= x); + }, x => _data.VolumeChangeRequested += x, x => _data.VolumeChangeRequested -= x); } } @@ -10236,85 +9282,77 @@ namespace Windows.Media.Protection /// /// A wrapper class which wraps all the events contained within the class. /// - public static HdcpSessionEvents Events(this global::Windows.Media.Protection.HdcpSession item) => new HdcpSessionEvents(item); + public static RxHdcpSessionEvents Events(this global::Windows.Media.Protection.HdcpSession item) => new RxHdcpSessionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaProtectionManagerEvents Events(this global::Windows.Media.Protection.MediaProtectionManager item) => new MediaProtectionManagerEvents(item); + public static RxMediaProtectionManagerEvents Events(this global::Windows.Media.Protection.MediaProtectionManager item) => new RxMediaProtectionManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class HdcpSessionEvents + public class RxHdcpSessionEvents { private readonly global::Windows.Media.Protection.HdcpSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public HdcpSessionEvents(global::Windows.Media.Protection.HdcpSession data) + public RxHdcpSessionEvents(global::Windows.Media.Protection.HdcpSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Protection.HdcpSession sender, object args)> ProtectionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.HdcpSession sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Protection.HdcpSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProtectionChanged += x, x => _data.ProtectionChanged -= x); + }, x => _data.ProtectionChanged += x, x => _data.ProtectionChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaProtectionManagerEvents + public class RxMediaProtectionManagerEvents { private readonly global::Windows.Media.Protection.MediaProtectionManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaProtectionManagerEvents(global::Windows.Media.Protection.MediaProtectionManager data) + public RxMediaProtectionManagerEvents(global::Windows.Media.Protection.MediaProtectionManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ComponentLoadFailedEventArgs e)> ComponentLoadFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ComponentLoadFailedEventArgs e) => eventHandler((sender, e)); return Handler; - } - - , x => _data.ComponentLoadFailed += x, x => _data.ComponentLoadFailed -= x); + }, x => _data.ComponentLoadFailed += x, x => _data.ComponentLoadFailed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable RebootNeeded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(global::Windows.Media.Protection.MediaProtectionManager sender) => eventHandler(sender); return Handler; - } - - , x => _data.RebootNeeded += x, x => _data.RebootNeeded -= x); + }, x => _data.RebootNeeded += x, x => _data.RebootNeeded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ServiceRequestedEventArgs e)> ServiceRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ServiceRequestedEventArgs e) => eventHandler((sender, e)); return Handler; - } - - , x => _data.ServiceRequested += x, x => _data.ServiceRequested -= x); + }, x => _data.ServiceRequested += x, x => _data.ServiceRequested -= x); } } @@ -10328,74 +9366,64 @@ namespace Windows.Media.Protection.PlayReady /// /// A wrapper class which wraps all the events contained within the class. /// - public static NDClientEvents Events(this global::Windows.Media.Protection.PlayReady.NDClient item) => new NDClientEvents(item); + public static RxNDClientEvents Events(this global::Windows.Media.Protection.PlayReady.NDClient item) => new RxNDClientEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class NDClientEvents + public class RxNDClientEvents { private readonly global::Windows.Media.Protection.PlayReady.NDClient _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public NDClientEvents(global::Windows.Media.Protection.PlayReady.NDClient data) + public RxNDClientEvents(global::Windows.Media.Protection.PlayReady.NDClient data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args)> ClosedCaptionDataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ClosedCaptionDataReceived += x, x => _data.ClosedCaptionDataReceived -= x); + }, x => _data.ClosedCaptionDataReceived += x, x => _data.ClosedCaptionDataReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args)> LicenseFetchCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LicenseFetchCompleted += x, x => _data.LicenseFetchCompleted -= x); + }, x => _data.LicenseFetchCompleted += x, x => _data.LicenseFetchCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args)> ProximityDetectionCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProximityDetectionCompleted += x, x => _data.ProximityDetectionCompleted -= x); + }, x => _data.ProximityDetectionCompleted += x, x => _data.ProximityDetectionCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args)> RegistrationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RegistrationCompleted += x, x => _data.RegistrationCompleted -= x); + }, x => _data.RegistrationCompleted += x, x => _data.RegistrationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Protection.PlayReady.NDClient sender, object args)> ReRegistrationNeeded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Protection.PlayReady.NDClient sender, object args)>(eventHandler => { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReRegistrationNeeded += x, x => _data.ReRegistrationNeeded -= x); + }, x => _data.ReRegistrationNeeded += x, x => _data.ReRegistrationNeeded -= x); } } @@ -10409,95 +9437,85 @@ namespace Windows.Media.SpeechRecognition /// /// A wrapper class which wraps all the events contained within the class. /// - public static SpeechContinuousRecognitionSessionEvents Events(this global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession item) => new SpeechContinuousRecognitionSessionEvents(item); + public static RxSpeechContinuousRecognitionSessionEvents Events(this global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession item) => new RxSpeechContinuousRecognitionSessionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SpeechRecognizerEvents Events(this global::Windows.Media.SpeechRecognition.SpeechRecognizer item) => new SpeechRecognizerEvents(item); + public static RxSpeechRecognizerEvents Events(this global::Windows.Media.SpeechRecognition.SpeechRecognizer item) => new RxSpeechRecognizerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class SpeechContinuousRecognitionSessionEvents + public class RxSpeechContinuousRecognitionSessionEvents { private readonly global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SpeechContinuousRecognitionSessionEvents(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession data) + public RxSpeechContinuousRecognitionSessionEvents(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args)> ResultGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResultGenerated += x, x => _data.ResultGenerated -= x); + }, x => _data.ResultGenerated += x, x => _data.ResultGenerated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SpeechRecognizerEvents + public class RxSpeechRecognizerEvents { private readonly global::Windows.Media.SpeechRecognition.SpeechRecognizer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SpeechRecognizerEvents(global::Windows.Media.SpeechRecognition.SpeechRecognizer data) + public RxSpeechRecognizerEvents(global::Windows.Media.SpeechRecognition.SpeechRecognizer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args)> HypothesisGenerated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HypothesisGenerated += x, x => _data.HypothesisGenerated -= x); + }, x => _data.HypothesisGenerated += x, x => _data.HypothesisGenerated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args)> RecognitionQualityDegrading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RecognitionQualityDegrading += x, x => _data.RecognitionQualityDegrading -= x); + }, x => _data.RecognitionQualityDegrading += x, x => _data.RecognitionQualityDegrading -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -10511,105 +9529,93 @@ namespace Windows.Media.Streaming.Adaptive /// /// A wrapper class which wraps all the events contained within the class. /// - public static AdaptiveMediaSourceEvents Events(this global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource item) => new AdaptiveMediaSourceEvents(item); + public static RxAdaptiveMediaSourceEvents Events(this global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource item) => new RxAdaptiveMediaSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AdaptiveMediaSourceDiagnosticsEvents Events(this global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics item) => new AdaptiveMediaSourceDiagnosticsEvents(item); + public static RxAdaptiveMediaSourceDiagnosticsEvents Events(this global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics item) => new RxAdaptiveMediaSourceDiagnosticsEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AdaptiveMediaSourceEvents + public class RxAdaptiveMediaSourceEvents { private readonly global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AdaptiveMediaSourceEvents(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource data) + public RxAdaptiveMediaSourceEvents(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args)> DownloadBitrateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadBitrateChanged += x, x => _data.DownloadBitrateChanged -= x); + }, x => _data.DownloadBitrateChanged += x, x => _data.DownloadBitrateChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args)> DownloadCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args)> DownloadFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args)> DownloadRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadRequested += x, x => _data.DownloadRequested -= x); + }, x => _data.DownloadRequested += x, x => _data.DownloadRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args)> PlaybackBitrateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackBitrateChanged += x, x => _data.PlaybackBitrateChanged -= x); + }, x => _data.PlaybackBitrateChanged += x, x => _data.PlaybackBitrateChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AdaptiveMediaSourceDiagnosticsEvents + public class RxAdaptiveMediaSourceDiagnosticsEvents { private readonly global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AdaptiveMediaSourceDiagnosticsEvents(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics data) + public RxAdaptiveMediaSourceDiagnosticsEvents(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args)> DiagnosticAvailable => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args)>(eventHandler => { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DiagnosticAvailable += x, x => _data.DiagnosticAvailable -= x); + }, x => _data.DiagnosticAvailable += x, x => _data.DiagnosticAvailable -= x); } } @@ -10623,34 +9629,32 @@ namespace Windows.Networking.BackgroundTransfer /// /// A wrapper class which wraps all the events contained within the class. /// - public static DownloadOperationEvents Events(this global::Windows.Networking.BackgroundTransfer.DownloadOperation item) => new DownloadOperationEvents(item); + public static RxDownloadOperationEvents Events(this global::Windows.Networking.BackgroundTransfer.DownloadOperation item) => new RxDownloadOperationEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class DownloadOperationEvents + public class RxDownloadOperationEvents { private readonly global::Windows.Networking.BackgroundTransfer.DownloadOperation _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DownloadOperationEvents(global::Windows.Networking.BackgroundTransfer.DownloadOperation data) + public RxDownloadOperationEvents(global::Windows.Networking.BackgroundTransfer.DownloadOperation data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args)> RangesDownloaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RangesDownloaded += x, x => _data.RangesDownloaded -= x); + }, x => _data.RangesDownloaded += x, x => _data.RangesDownloaded -= x); } } @@ -10664,300 +9668,270 @@ namespace Windows.Networking.NetworkOperators /// /// A wrapper class which wraps all the events contained within the class. /// - public static ESimEvents Events(this global::Windows.Networking.NetworkOperators.ESim item) => new ESimEvents(item); + public static RxESimEvents Events(this global::Windows.Networking.NetworkOperators.ESim item) => new RxESimEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ESimProfileMetadataEvents Events(this global::Windows.Networking.NetworkOperators.ESimProfileMetadata item) => new ESimProfileMetadataEvents(item); + public static RxESimProfileMetadataEvents Events(this global::Windows.Networking.NetworkOperators.ESimProfileMetadata item) => new RxESimProfileMetadataEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ESimWatcherEvents Events(this global::Windows.Networking.NetworkOperators.ESimWatcher item) => new ESimWatcherEvents(item); + public static RxESimWatcherEvents Events(this global::Windows.Networking.NetworkOperators.ESimWatcher item) => new RxESimWatcherEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MobileBroadbandAccountWatcherEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher item) => new MobileBroadbandAccountWatcherEvents(item); + public static RxMobileBroadbandAccountWatcherEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher item) => new RxMobileBroadbandAccountWatcherEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MobileBroadbandDeviceServiceDataSessionEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession item) => new MobileBroadbandDeviceServiceDataSessionEvents(item); + public static RxMobileBroadbandDeviceServiceDataSessionEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession item) => new RxMobileBroadbandDeviceServiceDataSessionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MobileBroadbandModemEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandModem item) => new MobileBroadbandModemEvents(item); + public static RxMobileBroadbandModemEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandModem item) => new RxMobileBroadbandModemEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MobileBroadbandSarManagerEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager item) => new MobileBroadbandSarManagerEvents(item); + public static RxMobileBroadbandSarManagerEvents Events(this global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager item) => new RxMobileBroadbandSarManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ESimEvents + public class RxESimEvents { private readonly global::Windows.Networking.NetworkOperators.ESim _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ESimEvents(global::Windows.Networking.NetworkOperators.ESim data) + public RxESimEvents(global::Windows.Networking.NetworkOperators.ESim data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESim sender, object args)> ProfileChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESim sender, object args)>(eventHandler => { void Handler(global::Windows.Networking.NetworkOperators.ESim sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProfileChanged += x, x => _data.ProfileChanged -= x); + }, x => _data.ProfileChanged += x, x => _data.ProfileChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ESimProfileMetadataEvents + public class RxESimProfileMetadataEvents { private readonly global::Windows.Networking.NetworkOperators.ESimProfileMetadata _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ESimProfileMetadataEvents(global::Windows.Networking.NetworkOperators.ESimProfileMetadata data) + public RxESimProfileMetadataEvents(global::Windows.Networking.NetworkOperators.ESimProfileMetadata data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args)> StateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args)>(eventHandler => { void Handler(global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ESimWatcherEvents + public class RxESimWatcherEvents { private readonly global::Windows.Networking.NetworkOperators.ESimWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ESimWatcherEvents(global::Windows.Networking.NetworkOperators.ESimWatcher data) + public RxESimWatcherEvents(global::Windows.Networking.NetworkOperators.ESimWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MobileBroadbandAccountWatcherEvents + public class RxMobileBroadbandAccountWatcherEvents { private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MobileBroadbandAccountWatcherEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher data) + public RxMobileBroadbandAccountWatcherEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)> AccountAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountAdded += x, x => _data.AccountAdded -= x); + }, x => _data.AccountAdded += x, x => _data.AccountAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)> AccountRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountRemoved += x, x => _data.AccountRemoved -= x); + }, x => _data.AccountRemoved += x, x => _data.AccountRemoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args)> AccountUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountUpdated += x, x => _data.AccountUpdated -= x); + }, x => _data.AccountUpdated += x, x => _data.AccountUpdated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MobileBroadbandDeviceServiceDataSessionEvents + public class RxMobileBroadbandDeviceServiceDataSessionEvents { private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MobileBroadbandDeviceServiceDataSessionEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession data) + public RxMobileBroadbandDeviceServiceDataSessionEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args)> DataReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MobileBroadbandModemEvents + public class RxMobileBroadbandModemEvents { private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandModem _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MobileBroadbandModemEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandModem data) + public RxMobileBroadbandModemEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandModem data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args)> IsInEmergencyCallModeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args)>(eventHandler => { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsInEmergencyCallModeChanged += x, x => _data.IsInEmergencyCallModeChanged -= x); + }, x => _data.IsInEmergencyCallModeChanged += x, x => _data.IsInEmergencyCallModeChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MobileBroadbandSarManagerEvents + public class RxMobileBroadbandSarManagerEvents { private readonly global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MobileBroadbandSarManagerEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager data) + public RxMobileBroadbandSarManagerEvents(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args)> TransmissionStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TransmissionStateChanged += x, x => _data.TransmissionStateChanged -= x); + }, x => _data.TransmissionStateChanged += x, x => _data.TransmissionStateChanged -= x); } } @@ -10971,115 +9945,101 @@ namespace Windows.Networking.Proximity /// /// A wrapper class which wraps all the events contained within the class. /// - public static PeerWatcherEvents Events(this global::Windows.Networking.Proximity.PeerWatcher item) => new PeerWatcherEvents(item); + public static RxPeerWatcherEvents Events(this global::Windows.Networking.Proximity.PeerWatcher item) => new RxPeerWatcherEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ProximityDeviceEvents Events(this global::Windows.Networking.Proximity.ProximityDevice item) => new ProximityDeviceEvents(item); + public static RxProximityDeviceEvents Events(this global::Windows.Networking.Proximity.ProximityDevice item) => new RxProximityDeviceEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class PeerWatcherEvents + public class RxPeerWatcherEvents { private readonly global::Windows.Networking.Proximity.PeerWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PeerWatcherEvents(global::Windows.Networking.Proximity.PeerWatcher data) + public RxPeerWatcherEvents(global::Windows.Networking.Proximity.PeerWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)>(eventHandler => { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)>(eventHandler => { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args)>(eventHandler => { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ProximityDeviceEvents + public class RxProximityDeviceEvents { private readonly global::Windows.Networking.Proximity.ProximityDevice _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ProximityDeviceEvents(global::Windows.Networking.Proximity.ProximityDevice data) + public RxProximityDeviceEvents(global::Windows.Networking.Proximity.ProximityDevice data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DeviceArrived => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); return Handler; - } - - , x => _data.DeviceArrived += x, x => _data.DeviceArrived -= x); + }, x => _data.DeviceArrived += x, x => _data.DeviceArrived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DeviceDeparted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); return Handler; - } - - , x => _data.DeviceDeparted += x, x => _data.DeviceDeparted -= x); + }, x => _data.DeviceDeparted += x, x => _data.DeviceDeparted -= x); } } @@ -11093,34 +10053,32 @@ namespace Windows.Networking.PushNotifications /// /// A wrapper class which wraps all the events contained within the class. /// - public static PushNotificationChannelEvents Events(this global::Windows.Networking.PushNotifications.PushNotificationChannel item) => new PushNotificationChannelEvents(item); + public static RxPushNotificationChannelEvents Events(this global::Windows.Networking.PushNotifications.PushNotificationChannel item) => new RxPushNotificationChannelEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class PushNotificationChannelEvents + public class RxPushNotificationChannelEvents { private readonly global::Windows.Networking.PushNotifications.PushNotificationChannel _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PushNotificationChannelEvents(global::Windows.Networking.PushNotifications.PushNotificationChannel data) + public RxPushNotificationChannelEvents(global::Windows.Networking.PushNotifications.PushNotificationChannel data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args)> PushNotificationReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PushNotificationReceived += x, x => _data.PushNotificationReceived -= x); + }, x => _data.PushNotificationReceived += x, x => _data.PushNotificationReceived -= x); } } @@ -11134,54 +10092,48 @@ namespace Windows.Networking.ServiceDiscovery.Dnssd /// /// A wrapper class which wraps all the events contained within the class. /// - public static DnssdServiceWatcherEvents Events(this global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher item) => new DnssdServiceWatcherEvents(item); + public static RxDnssdServiceWatcherEvents Events(this global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher item) => new RxDnssdServiceWatcherEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class DnssdServiceWatcherEvents + public class RxDnssdServiceWatcherEvents { private readonly global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DnssdServiceWatcherEvents(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher data) + public RxDnssdServiceWatcherEvents(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args)>(eventHandler => { void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -11195,260 +10147,238 @@ namespace Windows.Networking.Sockets /// /// A wrapper class which wraps all the events contained within the class. /// - public static DatagramSocketEvents Events(this global::Windows.Networking.Sockets.DatagramSocket item) => new DatagramSocketEvents(item); + public static RxDatagramSocketEvents Events(this global::Windows.Networking.Sockets.DatagramSocket item) => new RxDatagramSocketEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IWebSocketEvents Events(this global::Windows.Networking.Sockets.IWebSocket item) => new IWebSocketEvents(item); + public static RxIWebSocketEvents Events(this global::Windows.Networking.Sockets.IWebSocket item) => new RxIWebSocketEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MessageWebSocketEvents Events(this global::Windows.Networking.Sockets.MessageWebSocket item) => new MessageWebSocketEvents(item); + public static RxMessageWebSocketEvents Events(this global::Windows.Networking.Sockets.MessageWebSocket item) => new RxMessageWebSocketEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ServerMessageWebSocketEvents Events(this global::Windows.Networking.Sockets.ServerMessageWebSocket item) => new ServerMessageWebSocketEvents(item); + public static RxServerMessageWebSocketEvents Events(this global::Windows.Networking.Sockets.ServerMessageWebSocket item) => new RxServerMessageWebSocketEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ServerStreamWebSocketEvents Events(this global::Windows.Networking.Sockets.ServerStreamWebSocket item) => new ServerStreamWebSocketEvents(item); + public static RxServerStreamWebSocketEvents Events(this global::Windows.Networking.Sockets.ServerStreamWebSocket item) => new RxServerStreamWebSocketEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static StreamSocketListenerEvents Events(this global::Windows.Networking.Sockets.StreamSocketListener item) => new StreamSocketListenerEvents(item); + public static RxStreamSocketListenerEvents Events(this global::Windows.Networking.Sockets.StreamSocketListener item) => new RxStreamSocketListenerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static StreamWebSocketEvents Events(this global::Windows.Networking.Sockets.StreamWebSocket item) => new StreamWebSocketEvents(item); + public static RxStreamWebSocketEvents Events(this global::Windows.Networking.Sockets.StreamWebSocket item) => new RxStreamWebSocketEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class DatagramSocketEvents + public class RxDatagramSocketEvents { private readonly global::Windows.Networking.Sockets.DatagramSocket _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DatagramSocketEvents(global::Windows.Networking.Sockets.DatagramSocket data) + public RxDatagramSocketEvents(global::Windows.Networking.Sockets.DatagramSocket data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IWebSocketEvents + public class RxIWebSocketEvents { private readonly global::Windows.Networking.Sockets.IWebSocket _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IWebSocketEvents(global::Windows.Networking.Sockets.IWebSocket data) + public RxIWebSocketEvents(global::Windows.Networking.Sockets.IWebSocket data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MessageWebSocketEvents + public class RxMessageWebSocketEvents { private readonly global::Windows.Networking.Sockets.MessageWebSocket _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MessageWebSocketEvents(global::Windows.Networking.Sockets.MessageWebSocket data) + public RxMessageWebSocketEvents(global::Windows.Networking.Sockets.MessageWebSocket data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)> ServerCustomValidationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ServerMessageWebSocketEvents + public class RxServerMessageWebSocketEvents { private readonly global::Windows.Networking.Sockets.ServerMessageWebSocket _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ServerMessageWebSocketEvents(global::Windows.Networking.Sockets.ServerMessageWebSocket data) + public RxServerMessageWebSocketEvents(global::Windows.Networking.Sockets.ServerMessageWebSocket data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)> MessageReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ServerStreamWebSocketEvents + public class RxServerStreamWebSocketEvents { private readonly global::Windows.Networking.Sockets.ServerStreamWebSocket _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ServerStreamWebSocketEvents(global::Windows.Networking.Sockets.ServerStreamWebSocket data) + public RxServerStreamWebSocketEvents(global::Windows.Networking.Sockets.ServerStreamWebSocket data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class StreamSocketListenerEvents + public class RxStreamSocketListenerEvents { private readonly global::Windows.Networking.Sockets.StreamSocketListener _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public StreamSocketListenerEvents(global::Windows.Networking.Sockets.StreamSocketListener data) + public RxStreamSocketListenerEvents(global::Windows.Networking.Sockets.StreamSocketListener data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args)> ConnectionReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionReceived += x, x => _data.ConnectionReceived -= x); + }, x => _data.ConnectionReceived += x, x => _data.ConnectionReceived -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class StreamWebSocketEvents + public class RxStreamWebSocketEvents { private readonly global::Windows.Networking.Sockets.StreamWebSocket _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public StreamWebSocketEvents(global::Windows.Networking.Sockets.StreamWebSocket data) + public RxStreamWebSocketEvents(global::Windows.Networking.Sockets.StreamWebSocket data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)> ServerCustomValidationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); } } @@ -11462,44 +10392,40 @@ namespace Windows.Networking.Vpn /// /// A wrapper class which wraps all the events contained within the class. /// - public static VpnChannelEvents Events(this global::Windows.Networking.Vpn.VpnChannel item) => new VpnChannelEvents(item); + public static RxVpnChannelEvents Events(this global::Windows.Networking.Vpn.VpnChannel item) => new RxVpnChannelEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class VpnChannelEvents + public class RxVpnChannelEvents { private readonly global::Windows.Networking.Vpn.VpnChannel _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public VpnChannelEvents(global::Windows.Networking.Vpn.VpnChannel data) + public RxVpnChannelEvents(global::Windows.Networking.Vpn.VpnChannel data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args)> ActivityChange => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args)>(eventHandler => { void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActivityChange += x, x => _data.ActivityChange -= x); + }, x => _data.ActivityChange += x, x => _data.ActivityChange -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args)> ActivityStateChange => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args)>(eventHandler => { void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActivityStateChange += x, x => _data.ActivityStateChange -= x); + }, x => _data.ActivityStateChange += x, x => _data.ActivityStateChange -= x); } } @@ -11513,136 +10439,122 @@ namespace Windows.Perception.Spatial /// /// A wrapper class which wraps all the events contained within the class. /// - public static SpatialAnchorEvents Events(this global::Windows.Perception.Spatial.SpatialAnchor item) => new SpatialAnchorEvents(item); + public static RxSpatialAnchorEvents Events(this global::Windows.Perception.Spatial.SpatialAnchor item) => new RxSpatialAnchorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SpatialEntityWatcherEvents Events(this global::Windows.Perception.Spatial.SpatialEntityWatcher item) => new SpatialEntityWatcherEvents(item); + public static RxSpatialEntityWatcherEvents Events(this global::Windows.Perception.Spatial.SpatialEntityWatcher item) => new RxSpatialEntityWatcherEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SpatialLocatorEvents Events(this global::Windows.Perception.Spatial.SpatialLocator item) => new SpatialLocatorEvents(item); + public static RxSpatialLocatorEvents Events(this global::Windows.Perception.Spatial.SpatialLocator item) => new RxSpatialLocatorEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class SpatialAnchorEvents + public class RxSpatialAnchorEvents { private readonly global::Windows.Perception.Spatial.SpatialAnchor _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SpatialAnchorEvents(global::Windows.Perception.Spatial.SpatialAnchor data) + public RxSpatialAnchorEvents(global::Windows.Perception.Spatial.SpatialAnchor data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args)> RawCoordinateSystemAdjusted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args)>(eventHandler => { void Handler(global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RawCoordinateSystemAdjusted += x, x => _data.RawCoordinateSystemAdjusted -= x); + }, x => _data.RawCoordinateSystemAdjusted += x, x => _data.RawCoordinateSystemAdjusted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SpatialEntityWatcherEvents + public class RxSpatialEntityWatcherEvents { private readonly global::Windows.Perception.Spatial.SpatialEntityWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SpatialEntityWatcherEvents(global::Windows.Perception.Spatial.SpatialEntityWatcher data) + public RxSpatialEntityWatcherEvents(global::Windows.Perception.Spatial.SpatialEntityWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args)>(eventHandler => { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args)>(eventHandler => { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args)>(eventHandler => { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SpatialLocatorEvents + public class RxSpatialLocatorEvents { private readonly global::Windows.Perception.Spatial.SpatialLocator _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SpatialLocatorEvents(global::Windows.Perception.Spatial.SpatialLocator data) + public RxSpatialLocatorEvents(global::Windows.Perception.Spatial.SpatialLocator data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialLocator sender, object args)> LocatabilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialLocator sender, object args)>(eventHandler => { void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LocatabilityChanged += x, x => _data.LocatabilityChanged -= x); + }, x => _data.LocatabilityChanged += x, x => _data.LocatabilityChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args)> PositionalTrackingDeactivating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args)>(eventHandler => { void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionalTrackingDeactivating += x, x => _data.PositionalTrackingDeactivating -= x); + }, x => _data.PositionalTrackingDeactivating += x, x => _data.PositionalTrackingDeactivating -= x); } } @@ -11656,34 +10568,32 @@ namespace Windows.Perception.Spatial.Surfaces /// /// A wrapper class which wraps all the events contained within the class. /// - public static SpatialSurfaceObserverEvents Events(this global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver item) => new SpatialSurfaceObserverEvents(item); + public static RxSpatialSurfaceObserverEvents Events(this global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver item) => new RxSpatialSurfaceObserverEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class SpatialSurfaceObserverEvents + public class RxSpatialSurfaceObserverEvents { private readonly global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SpatialSurfaceObserverEvents(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver data) + public RxSpatialSurfaceObserverEvents(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args)> ObservedSurfacesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args)>(eventHandler => { void Handler(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ObservedSurfacesChanged += x, x => _data.ObservedSurfacesChanged -= x); + }, x => _data.ObservedSurfacesChanged += x, x => _data.ObservedSurfacesChanged -= x); } } @@ -11697,34 +10607,32 @@ namespace Windows.Phone.Devices.Power /// /// A wrapper class which wraps all the events contained within the class. /// - public static BatteryEvents Events(this global::Windows.Phone.Devices.Power.Battery item) => new BatteryEvents(item); + public static RxBatteryEvents Events(this global::Windows.Phone.Devices.Power.Battery item) => new RxBatteryEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class BatteryEvents + public class RxBatteryEvents { private readonly global::Windows.Phone.Devices.Power.Battery _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BatteryEvents(global::Windows.Phone.Devices.Power.Battery data) + public RxBatteryEvents(global::Windows.Phone.Devices.Power.Battery data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable RemainingChargePercentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingChargePercentChanged += x, x => _data.RemainingChargePercentChanged -= x); + }, x => _data.RemainingChargePercentChanged += x, x => _data.RemainingChargePercentChanged -= x); } } @@ -11738,34 +10646,32 @@ namespace Windows.Phone.Media.Devices /// /// A wrapper class which wraps all the events contained within the class. /// - public static AudioRoutingManagerEvents Events(this global::Windows.Phone.Media.Devices.AudioRoutingManager item) => new AudioRoutingManagerEvents(item); + public static RxAudioRoutingManagerEvents Events(this global::Windows.Phone.Media.Devices.AudioRoutingManager item) => new RxAudioRoutingManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AudioRoutingManagerEvents + public class RxAudioRoutingManagerEvents { private readonly global::Windows.Phone.Media.Devices.AudioRoutingManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AudioRoutingManagerEvents(global::Windows.Phone.Media.Devices.AudioRoutingManager data) + public RxAudioRoutingManagerEvents(global::Windows.Phone.Media.Devices.AudioRoutingManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args)> AudioEndpointChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args)>(eventHandler => { void Handler(global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioEndpointChanged += x, x => _data.AudioEndpointChanged -= x); + }, x => _data.AudioEndpointChanged += x, x => _data.AudioEndpointChanged -= x); } } @@ -11779,54 +10685,48 @@ namespace Windows.Security.Authentication.Web.Core /// /// A wrapper class which wraps all the events contained within the class. /// - public static WebAccountMonitorEvents Events(this global::Windows.Security.Authentication.Web.Core.WebAccountMonitor item) => new WebAccountMonitorEvents(item); + public static RxWebAccountMonitorEvents Events(this global::Windows.Security.Authentication.Web.Core.WebAccountMonitor item) => new RxWebAccountMonitorEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class WebAccountMonitorEvents + public class RxWebAccountMonitorEvents { private readonly global::Windows.Security.Authentication.Web.Core.WebAccountMonitor _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WebAccountMonitorEvents(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor data) + public RxWebAccountMonitorEvents(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args)> DefaultSignInAccountChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args)>(eventHandler => { void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DefaultSignInAccountChanged += x, x => _data.DefaultSignInAccountChanged -= x); + }, x => _data.DefaultSignInAccountChanged += x, x => _data.DefaultSignInAccountChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)>(eventHandler => { void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args)>(eventHandler => { void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -11840,34 +10740,32 @@ namespace Windows.Security.Credentials /// /// A wrapper class which wraps all the events contained within the class. /// - public static PasswordCredentialPropertyStoreEvents Events(this global::Windows.Security.Credentials.PasswordCredentialPropertyStore item) => new PasswordCredentialPropertyStoreEvents(item); + public static RxPasswordCredentialPropertyStoreEvents Events(this global::Windows.Security.Credentials.PasswordCredentialPropertyStore item) => new RxPasswordCredentialPropertyStoreEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class PasswordCredentialPropertyStoreEvents + public class RxPasswordCredentialPropertyStoreEvents { private readonly global::Windows.Security.Credentials.PasswordCredentialPropertyStore _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PasswordCredentialPropertyStoreEvents(global::Windows.Security.Credentials.PasswordCredentialPropertyStore data) + public RxPasswordCredentialPropertyStoreEvents(global::Windows.Security.Credentials.PasswordCredentialPropertyStore data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } } @@ -11881,34 +10779,32 @@ namespace Windows.Services.Maps.OfflineMaps /// /// A wrapper class which wraps all the events contained within the class. /// - public static OfflineMapPackageEvents Events(this global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage item) => new OfflineMapPackageEvents(item); + public static RxOfflineMapPackageEvents Events(this global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage item) => new RxOfflineMapPackageEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class OfflineMapPackageEvents + public class RxOfflineMapPackageEvents { private readonly global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public OfflineMapPackageEvents(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage data) + public RxOfflineMapPackageEvents(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args)> StatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args)>(eventHandler => { void Handler(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } } @@ -11922,127 +10818,119 @@ namespace Windows.Storage /// /// A wrapper class which wraps all the events contained within the class. /// - public static ApplicationDataEvents Events(this global::Windows.Storage.ApplicationData item) => new ApplicationDataEvents(item); + public static RxApplicationDataEvents Events(this global::Windows.Storage.ApplicationData item) => new RxApplicationDataEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ApplicationDataCompositeValueEvents Events(this global::Windows.Storage.ApplicationDataCompositeValue item) => new ApplicationDataCompositeValueEvents(item); + public static RxApplicationDataCompositeValueEvents Events(this global::Windows.Storage.ApplicationDataCompositeValue item) => new RxApplicationDataCompositeValueEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ApplicationDataContainerSettingsEvents Events(this global::Windows.Storage.ApplicationDataContainerSettings item) => new ApplicationDataContainerSettingsEvents(item); + public static RxApplicationDataContainerSettingsEvents Events(this global::Windows.Storage.ApplicationDataContainerSettings item) => new RxApplicationDataContainerSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static StorageLibraryEvents Events(this global::Windows.Storage.StorageLibrary item) => new StorageLibraryEvents(item); + public static RxStorageLibraryEvents Events(this global::Windows.Storage.StorageLibrary item) => new RxStorageLibraryEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ApplicationDataEvents + public class RxApplicationDataEvents { private readonly global::Windows.Storage.ApplicationData _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ApplicationDataEvents(global::Windows.Storage.ApplicationData data) + public RxApplicationDataEvents(global::Windows.Storage.ApplicationData data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.ApplicationData sender, object args)> DataChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.ApplicationData sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.ApplicationData sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataChanged += x, x => _data.DataChanged -= x); + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ApplicationDataCompositeValueEvents + public class RxApplicationDataCompositeValueEvents { private readonly global::Windows.Storage.ApplicationDataCompositeValue _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ApplicationDataCompositeValueEvents(global::Windows.Storage.ApplicationDataCompositeValue data) + public RxApplicationDataCompositeValueEvents(global::Windows.Storage.ApplicationDataCompositeValue data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ApplicationDataContainerSettingsEvents + public class RxApplicationDataContainerSettingsEvents { private readonly global::Windows.Storage.ApplicationDataContainerSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ApplicationDataContainerSettingsEvents(global::Windows.Storage.ApplicationDataContainerSettings data) + public RxApplicationDataContainerSettingsEvents(global::Windows.Storage.ApplicationDataContainerSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)> MapChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event)>(eventHandler => { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class StorageLibraryEvents + public class RxStorageLibraryEvents { private readonly global::Windows.Storage.StorageLibrary _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public StorageLibraryEvents(global::Windows.Storage.StorageLibrary data) + public RxStorageLibraryEvents(global::Windows.Storage.StorageLibrary data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.StorageLibrary sender, object args)> DefinitionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.StorageLibrary sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.StorageLibrary sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DefinitionChanged += x, x => _data.DefinitionChanged -= x); + }, x => _data.DefinitionChanged += x, x => _data.DefinitionChanged -= x); } } @@ -12056,34 +10944,32 @@ namespace Windows.Storage.AccessCache /// /// A wrapper class which wraps all the events contained within the class. /// - public static StorageItemMostRecentlyUsedListEvents Events(this global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList item) => new StorageItemMostRecentlyUsedListEvents(item); + public static RxStorageItemMostRecentlyUsedListEvents Events(this global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList item) => new RxStorageItemMostRecentlyUsedListEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class StorageItemMostRecentlyUsedListEvents + public class RxStorageItemMostRecentlyUsedListEvents { private readonly global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public StorageItemMostRecentlyUsedListEvents(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList data) + public RxStorageItemMostRecentlyUsedListEvents(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args)> ItemRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args)>(eventHandler => { void Handler(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); } } @@ -12097,126 +10983,114 @@ namespace Windows.Storage.BulkAccess /// /// A wrapper class which wraps all the events contained within the class. /// - public static FileInformationEvents Events(this global::Windows.Storage.BulkAccess.FileInformation item) => new FileInformationEvents(item); + public static RxFileInformationEvents Events(this global::Windows.Storage.BulkAccess.FileInformation item) => new RxFileInformationEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static FolderInformationEvents Events(this global::Windows.Storage.BulkAccess.FolderInformation item) => new FolderInformationEvents(item); + public static RxFolderInformationEvents Events(this global::Windows.Storage.BulkAccess.FolderInformation item) => new RxFolderInformationEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IStorageItemInformationEvents Events(this global::Windows.Storage.BulkAccess.IStorageItemInformation item) => new IStorageItemInformationEvents(item); + public static RxIStorageItemInformationEvents Events(this global::Windows.Storage.BulkAccess.IStorageItemInformation item) => new RxIStorageItemInformationEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class FileInformationEvents + public class RxFileInformationEvents { private readonly global::Windows.Storage.BulkAccess.FileInformation _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public FileInformationEvents(global::Windows.Storage.BulkAccess.FileInformation data) + public RxFileInformationEvents(global::Windows.Storage.BulkAccess.FileInformation data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> PropertiesUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> ThumbnailUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class FolderInformationEvents + public class RxFolderInformationEvents { private readonly global::Windows.Storage.BulkAccess.FolderInformation _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public FolderInformationEvents(global::Windows.Storage.BulkAccess.FolderInformation data) + public RxFolderInformationEvents(global::Windows.Storage.BulkAccess.FolderInformation data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> PropertiesUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> ThumbnailUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IStorageItemInformationEvents + public class RxIStorageItemInformationEvents { private readonly global::Windows.Storage.BulkAccess.IStorageItemInformation _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IStorageItemInformationEvents(global::Windows.Storage.BulkAccess.IStorageItemInformation data) + public RxIStorageItemInformationEvents(global::Windows.Storage.BulkAccess.IStorageItemInformation data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> PropertiesUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)> ThumbnailUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); } } @@ -12230,85 +11104,77 @@ namespace Windows.Storage.Pickers.Provider /// /// A wrapper class which wraps all the events contained within the class. /// - public static FileOpenPickerUIEvents Events(this global::Windows.Storage.Pickers.Provider.FileOpenPickerUI item) => new FileOpenPickerUIEvents(item); + public static RxFileOpenPickerUIEvents Events(this global::Windows.Storage.Pickers.Provider.FileOpenPickerUI item) => new RxFileOpenPickerUIEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static FileSavePickerUIEvents Events(this global::Windows.Storage.Pickers.Provider.FileSavePickerUI item) => new FileSavePickerUIEvents(item); + public static RxFileSavePickerUIEvents Events(this global::Windows.Storage.Pickers.Provider.FileSavePickerUI item) => new RxFileSavePickerUIEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class FileOpenPickerUIEvents + public class RxFileOpenPickerUIEvents { private readonly global::Windows.Storage.Pickers.Provider.FileOpenPickerUI _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public FileOpenPickerUIEvents(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI data) + public RxFileOpenPickerUIEvents(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args)>(eventHandler => { void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args)> FileRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args)>(eventHandler => { void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileRemoved += x, x => _data.FileRemoved -= x); + }, x => _data.FileRemoved += x, x => _data.FileRemoved -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class FileSavePickerUIEvents + public class RxFileSavePickerUIEvents { private readonly global::Windows.Storage.Pickers.Provider.FileSavePickerUI _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public FileSavePickerUIEvents(global::Windows.Storage.Pickers.Provider.FileSavePickerUI data) + public RxFileSavePickerUIEvents(global::Windows.Storage.Pickers.Provider.FileSavePickerUI data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args)> FileNameChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileNameChanged += x, x => _data.FileNameChanged -= x); + }, x => _data.FileNameChanged += x, x => _data.FileNameChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args)> TargetFileRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetFileRequested += x, x => _data.TargetFileRequested -= x); + }, x => _data.TargetFileRequested += x, x => _data.TargetFileRequested -= x); } } @@ -12322,44 +11188,40 @@ namespace Windows.Storage.Provider /// /// A wrapper class which wraps all the events contained within the class. /// - public static CachedFileUpdaterUIEvents Events(this global::Windows.Storage.Provider.CachedFileUpdaterUI item) => new CachedFileUpdaterUIEvents(item); + public static RxCachedFileUpdaterUIEvents Events(this global::Windows.Storage.Provider.CachedFileUpdaterUI item) => new RxCachedFileUpdaterUIEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class CachedFileUpdaterUIEvents + public class RxCachedFileUpdaterUIEvents { private readonly global::Windows.Storage.Provider.CachedFileUpdaterUI _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CachedFileUpdaterUIEvents(global::Windows.Storage.Provider.CachedFileUpdaterUI data) + public RxCachedFileUpdaterUIEvents(global::Windows.Storage.Provider.CachedFileUpdaterUI data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args)> FileUpdateRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileUpdateRequested += x, x => _data.FileUpdateRequested -= x); + }, x => _data.FileUpdateRequested += x, x => _data.FileUpdateRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args)> UIRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UIRequested += x, x => _data.UIRequested -= x); + }, x => _data.UIRequested += x, x => _data.UIRequested -= x); } } @@ -12373,167 +11235,151 @@ namespace Windows.Storage.Search /// /// A wrapper class which wraps all the events contained within the class. /// - public static IStorageQueryResultBaseEvents Events(this global::Windows.Storage.Search.IStorageQueryResultBase item) => new IStorageQueryResultBaseEvents(item); + public static RxIStorageQueryResultBaseEvents Events(this global::Windows.Storage.Search.IStorageQueryResultBase item) => new RxIStorageQueryResultBaseEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static StorageFileQueryResultEvents Events(this global::Windows.Storage.Search.StorageFileQueryResult item) => new StorageFileQueryResultEvents(item); + public static RxStorageFileQueryResultEvents Events(this global::Windows.Storage.Search.StorageFileQueryResult item) => new RxStorageFileQueryResultEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static StorageFolderQueryResultEvents Events(this global::Windows.Storage.Search.StorageFolderQueryResult item) => new StorageFolderQueryResultEvents(item); + public static RxStorageFolderQueryResultEvents Events(this global::Windows.Storage.Search.StorageFolderQueryResult item) => new RxStorageFolderQueryResultEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static StorageItemQueryResultEvents Events(this global::Windows.Storage.Search.StorageItemQueryResult item) => new StorageItemQueryResultEvents(item); + public static RxStorageItemQueryResultEvents Events(this global::Windows.Storage.Search.StorageItemQueryResult item) => new RxStorageItemQueryResultEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class IStorageQueryResultBaseEvents + public class RxIStorageQueryResultBaseEvents { private readonly global::Windows.Storage.Search.IStorageQueryResultBase _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IStorageQueryResultBaseEvents(global::Windows.Storage.Search.IStorageQueryResultBase data) + public RxIStorageQueryResultBaseEvents(global::Windows.Storage.Search.IStorageQueryResultBase data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class StorageFileQueryResultEvents + public class RxStorageFileQueryResultEvents { private readonly global::Windows.Storage.Search.StorageFileQueryResult _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public StorageFileQueryResultEvents(global::Windows.Storage.Search.StorageFileQueryResult data) + public RxStorageFileQueryResultEvents(global::Windows.Storage.Search.StorageFileQueryResult data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class StorageFolderQueryResultEvents + public class RxStorageFolderQueryResultEvents { private readonly global::Windows.Storage.Search.StorageFolderQueryResult _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public StorageFolderQueryResultEvents(global::Windows.Storage.Search.StorageFolderQueryResult data) + public RxStorageFolderQueryResultEvents(global::Windows.Storage.Search.StorageFolderQueryResult data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class StorageItemQueryResultEvents + public class RxStorageItemQueryResultEvents { private readonly global::Windows.Storage.Search.StorageItemQueryResult _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public StorageItemQueryResultEvents(global::Windows.Storage.Search.StorageItemQueryResult data) + public RxStorageItemQueryResultEvents(global::Windows.Storage.Search.StorageItemQueryResult data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> ContentsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)> OptionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Storage.Search.IStorageQueryResultBase sender, object args)>(eventHandler => { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } } @@ -12547,298 +11393,260 @@ namespace Windows.System /// /// A wrapper class which wraps all the events contained within the class. /// - public static AppDiagnosticInfoWatcherEvents Events(this global::Windows.System.AppDiagnosticInfoWatcher item) => new AppDiagnosticInfoWatcherEvents(item); + public static RxAppDiagnosticInfoWatcherEvents Events(this global::Windows.System.AppDiagnosticInfoWatcher item) => new RxAppDiagnosticInfoWatcherEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AppResourceGroupInfoWatcherEvents Events(this global::Windows.System.AppResourceGroupInfoWatcher item) => new AppResourceGroupInfoWatcherEvents(item); + public static RxAppResourceGroupInfoWatcherEvents Events(this global::Windows.System.AppResourceGroupInfoWatcher item) => new RxAppResourceGroupInfoWatcherEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DispatcherQueueEvents Events(this global::Windows.System.DispatcherQueue item) => new DispatcherQueueEvents(item); + public static RxDispatcherQueueEvents Events(this global::Windows.System.DispatcherQueue item) => new RxDispatcherQueueEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DispatcherQueueTimerEvents Events(this global::Windows.System.DispatcherQueueTimer item) => new DispatcherQueueTimerEvents(item); + public static RxDispatcherQueueTimerEvents Events(this global::Windows.System.DispatcherQueueTimer item) => new RxDispatcherQueueTimerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static UserWatcherEvents Events(this global::Windows.System.UserWatcher item) => new UserWatcherEvents(item); + public static RxUserWatcherEvents Events(this global::Windows.System.UserWatcher item) => new RxUserWatcherEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AppDiagnosticInfoWatcherEvents + public class RxAppDiagnosticInfoWatcherEvents { private readonly global::Windows.System.AppDiagnosticInfoWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AppDiagnosticInfoWatcherEvents(global::Windows.System.AppDiagnosticInfoWatcher data) + public RxAppDiagnosticInfoWatcherEvents(global::Windows.System.AppDiagnosticInfoWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)>(eventHandler => { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args)>(eventHandler => { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.AppDiagnosticInfoWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppDiagnosticInfoWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AppResourceGroupInfoWatcherEvents + public class RxAppResourceGroupInfoWatcherEvents { private readonly global::Windows.System.AppResourceGroupInfoWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AppResourceGroupInfoWatcherEvents(global::Windows.System.AppResourceGroupInfoWatcher data) + public RxAppResourceGroupInfoWatcherEvents(global::Windows.System.AppResourceGroupInfoWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)>(eventHandler => { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args)> ExecutionStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ExecutionStateChanged += x, x => _data.ExecutionStateChanged -= x); + }, x => _data.ExecutionStateChanged += x, x => _data.ExecutionStateChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args)>(eventHandler => { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.AppResourceGroupInfoWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.AppResourceGroupInfoWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DispatcherQueueEvents + public class RxDispatcherQueueEvents { private readonly global::Windows.System.DispatcherQueue _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DispatcherQueueEvents(global::Windows.System.DispatcherQueue data) + public RxDispatcherQueueEvents(global::Windows.System.DispatcherQueue data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.DispatcherQueue sender, object args)> ShutdownCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.DispatcherQueue sender, object args)>(eventHandler => { void Handler(global::Windows.System.DispatcherQueue sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShutdownCompleted += x, x => _data.ShutdownCompleted -= x); + }, x => _data.ShutdownCompleted += x, x => _data.ShutdownCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args)> ShutdownStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args)>(eventHandler => { void Handler(global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShutdownStarting += x, x => _data.ShutdownStarting -= x); + }, x => _data.ShutdownStarting += x, x => _data.ShutdownStarting -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DispatcherQueueTimerEvents + public class RxDispatcherQueueTimerEvents { private readonly global::Windows.System.DispatcherQueueTimer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DispatcherQueueTimerEvents(global::Windows.System.DispatcherQueueTimer data) + public RxDispatcherQueueTimerEvents(global::Windows.System.DispatcherQueueTimer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.DispatcherQueueTimer sender, object args)> Tick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.DispatcherQueueTimer sender, object args)>(eventHandler => { void Handler(global::Windows.System.DispatcherQueueTimer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class UserWatcherEvents + public class RxUserWatcherEvents { private readonly global::Windows.System.UserWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public UserWatcherEvents(global::Windows.System.UserWatcher data) + public RxUserWatcherEvents(global::Windows.System.UserWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> AuthenticationStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AuthenticationStatusChanged += x, x => _data.AuthenticationStatusChanged -= x); + }, x => _data.AuthenticationStatusChanged += x, x => _data.AuthenticationStatusChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args)> AuthenticationStatusChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args)>(eventHandler => { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AuthenticationStatusChanging += x, x => _data.AuthenticationStatusChanging -= x); + }, x => _data.AuthenticationStatusChanging += x, x => _data.AuthenticationStatusChanging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.UserWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.UserWatcher sender, object args)> Stopped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -12852,44 +11660,40 @@ namespace Windows.System.Diagnostics.DevicePortal /// /// A wrapper class which wraps all the events contained within the class. /// - public static DevicePortalConnectionEvents Events(this global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection item) => new DevicePortalConnectionEvents(item); + public static RxDevicePortalConnectionEvents Events(this global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection item) => new RxDevicePortalConnectionEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class DevicePortalConnectionEvents + public class RxDevicePortalConnectionEvents { private readonly global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DevicePortalConnectionEvents(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection data) + public RxDevicePortalConnectionEvents(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args)> RequestReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); } } @@ -12903,34 +11707,32 @@ namespace Windows.System.Preview /// /// A wrapper class which wraps all the events contained within the class. /// - public static TwoPanelHingedDevicePosturePreviewEvents Events(this global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview item) => new TwoPanelHingedDevicePosturePreviewEvents(item); + public static RxTwoPanelHingedDevicePosturePreviewEvents Events(this global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview item) => new RxTwoPanelHingedDevicePosturePreviewEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class TwoPanelHingedDevicePosturePreviewEvents + public class RxTwoPanelHingedDevicePosturePreviewEvents { private readonly global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TwoPanelHingedDevicePosturePreviewEvents(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview data) + public RxTwoPanelHingedDevicePosturePreviewEvents(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args)> PostureChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PostureChanged += x, x => _data.PostureChanged -= x); + }, x => _data.PostureChanged += x, x => _data.PostureChanged -= x); } } @@ -12944,300 +11746,270 @@ namespace Windows.System.RemoteSystems /// /// A wrapper class which wraps all the events contained within the class. /// - public static RemoteSystemSessionEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSession item) => new RemoteSystemSessionEvents(item); + public static RxRemoteSystemSessionEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSession item) => new RxRemoteSystemSessionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RemoteSystemSessionControllerEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionController item) => new RemoteSystemSessionControllerEvents(item); + public static RxRemoteSystemSessionControllerEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionController item) => new RxRemoteSystemSessionControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RemoteSystemSessionInvitationListenerEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener item) => new RemoteSystemSessionInvitationListenerEvents(item); + public static RxRemoteSystemSessionInvitationListenerEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener item) => new RxRemoteSystemSessionInvitationListenerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RemoteSystemSessionMessageChannelEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel item) => new RemoteSystemSessionMessageChannelEvents(item); + public static RxRemoteSystemSessionMessageChannelEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel item) => new RxRemoteSystemSessionMessageChannelEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RemoteSystemSessionParticipantWatcherEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher item) => new RemoteSystemSessionParticipantWatcherEvents(item); + public static RxRemoteSystemSessionParticipantWatcherEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher item) => new RxRemoteSystemSessionParticipantWatcherEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RemoteSystemSessionWatcherEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher item) => new RemoteSystemSessionWatcherEvents(item); + public static RxRemoteSystemSessionWatcherEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher item) => new RxRemoteSystemSessionWatcherEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RemoteSystemWatcherEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemWatcher item) => new RemoteSystemWatcherEvents(item); + public static RxRemoteSystemWatcherEvents Events(this global::Windows.System.RemoteSystems.RemoteSystemWatcher item) => new RxRemoteSystemWatcherEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class RemoteSystemSessionEvents + public class RxRemoteSystemSessionEvents { private readonly global::Windows.System.RemoteSystems.RemoteSystemSession _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RemoteSystemSessionEvents(global::Windows.System.RemoteSystems.RemoteSystemSession data) + public RxRemoteSystemSessionEvents(global::Windows.System.RemoteSystems.RemoteSystemSession data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args)> Disconnected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Disconnected += x, x => _data.Disconnected -= x); + }, x => _data.Disconnected += x, x => _data.Disconnected -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RemoteSystemSessionControllerEvents + public class RxRemoteSystemSessionControllerEvents { private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RemoteSystemSessionControllerEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionController data) + public RxRemoteSystemSessionControllerEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionController data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args)> JoinRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.JoinRequested += x, x => _data.JoinRequested -= x); + }, x => _data.JoinRequested += x, x => _data.JoinRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RemoteSystemSessionInvitationListenerEvents + public class RxRemoteSystemSessionInvitationListenerEvents { private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RemoteSystemSessionInvitationListenerEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener data) + public RxRemoteSystemSessionInvitationListenerEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args)> InvitationReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InvitationReceived += x, x => _data.InvitationReceived -= x); + }, x => _data.InvitationReceived += x, x => _data.InvitationReceived -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RemoteSystemSessionMessageChannelEvents + public class RxRemoteSystemSessionMessageChannelEvents { private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RemoteSystemSessionMessageChannelEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel data) + public RxRemoteSystemSessionMessageChannelEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args)> ValueSetReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValueSetReceived += x, x => _data.ValueSetReceived -= x); + }, x => _data.ValueSetReceived += x, x => _data.ValueSetReceived -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RemoteSystemSessionParticipantWatcherEvents + public class RxRemoteSystemSessionParticipantWatcherEvents { private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RemoteSystemSessionParticipantWatcherEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher data) + public RxRemoteSystemSessionParticipantWatcherEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args)>(eventHandler => { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RemoteSystemSessionWatcherEvents + public class RxRemoteSystemSessionWatcherEvents { private readonly global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RemoteSystemSessionWatcherEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher data) + public RxRemoteSystemSessionWatcherEvents(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args)> Added => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args)> Removed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args)> Updated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RemoteSystemWatcherEvents + public class RxRemoteSystemWatcherEvents { private readonly global::Windows.System.RemoteSystems.RemoteSystemWatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RemoteSystemWatcherEvents(global::Windows.System.RemoteSystems.RemoteSystemWatcher data) + public RxRemoteSystemWatcherEvents(global::Windows.System.RemoteSystems.RemoteSystemWatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args)> EnumerationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args)> ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args)>(eventHandler => { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args)> RemoteSystemAdded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteSystemAdded += x, x => _data.RemoteSystemAdded -= x); + }, x => _data.RemoteSystemAdded += x, x => _data.RemoteSystemAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args)> RemoteSystemRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteSystemRemoved += x, x => _data.RemoteSystemRemoved -= x); + }, x => _data.RemoteSystemRemoved += x, x => _data.RemoteSystemRemoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args)> RemoteSystemUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args)>(eventHandler => { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteSystemUpdated += x, x => _data.RemoteSystemUpdated -= x); + }, x => _data.RemoteSystemUpdated += x, x => _data.RemoteSystemUpdated -= x); } } @@ -13251,34 +12023,32 @@ namespace Windows.UI.Accessibility /// /// A wrapper class which wraps all the events contained within the class. /// - public static ScreenReaderServiceEvents Events(this global::Windows.UI.Accessibility.ScreenReaderService item) => new ScreenReaderServiceEvents(item); + public static RxScreenReaderServiceEvents Events(this global::Windows.UI.Accessibility.ScreenReaderService item) => new RxScreenReaderServiceEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ScreenReaderServiceEvents + public class RxScreenReaderServiceEvents { private readonly global::Windows.UI.Accessibility.ScreenReaderService _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ScreenReaderServiceEvents(global::Windows.UI.Accessibility.ScreenReaderService data) + public RxScreenReaderServiceEvents(global::Windows.UI.Accessibility.ScreenReaderService data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args)> ScreenReaderPositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenReaderPositionChanged += x, x => _data.ScreenReaderPositionChanged -= x); + }, x => _data.ScreenReaderPositionChanged += x, x => _data.ScreenReaderPositionChanged -= x); } } @@ -13292,34 +12062,32 @@ namespace Windows.UI.ApplicationSettings /// /// A wrapper class which wraps all the events contained within the class. /// - public static AccountsSettingsPaneEvents Events(this global::Windows.UI.ApplicationSettings.AccountsSettingsPane item) => new AccountsSettingsPaneEvents(item); + public static RxAccountsSettingsPaneEvents Events(this global::Windows.UI.ApplicationSettings.AccountsSettingsPane item) => new RxAccountsSettingsPaneEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AccountsSettingsPaneEvents + public class RxAccountsSettingsPaneEvents { private readonly global::Windows.UI.ApplicationSettings.AccountsSettingsPane _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AccountsSettingsPaneEvents(global::Windows.UI.ApplicationSettings.AccountsSettingsPane data) + public RxAccountsSettingsPaneEvents(global::Windows.UI.ApplicationSettings.AccountsSettingsPane data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args)> AccountCommandsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountCommandsRequested += x, x => _data.AccountCommandsRequested -= x); + }, x => _data.AccountCommandsRequested += x, x => _data.AccountCommandsRequested -= x); } } @@ -13333,127 +12101,119 @@ namespace Windows.UI.Composition /// /// A wrapper class which wraps all the events contained within the class. /// - public static CompositionCapabilitiesEvents Events(this global::Windows.UI.Composition.CompositionCapabilities item) => new CompositionCapabilitiesEvents(item); + public static RxCompositionCapabilitiesEvents Events(this global::Windows.UI.Composition.CompositionCapabilities item) => new RxCompositionCapabilitiesEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CompositionCommitBatchEvents Events(this global::Windows.UI.Composition.CompositionCommitBatch item) => new CompositionCommitBatchEvents(item); + public static RxCompositionCommitBatchEvents Events(this global::Windows.UI.Composition.CompositionCommitBatch item) => new RxCompositionCommitBatchEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CompositionGraphicsDeviceEvents Events(this global::Windows.UI.Composition.CompositionGraphicsDevice item) => new CompositionGraphicsDeviceEvents(item); + public static RxCompositionGraphicsDeviceEvents Events(this global::Windows.UI.Composition.CompositionGraphicsDevice item) => new RxCompositionGraphicsDeviceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CompositionScopedBatchEvents Events(this global::Windows.UI.Composition.CompositionScopedBatch item) => new CompositionScopedBatchEvents(item); + public static RxCompositionScopedBatchEvents Events(this global::Windows.UI.Composition.CompositionScopedBatch item) => new RxCompositionScopedBatchEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class CompositionCapabilitiesEvents + public class RxCompositionCapabilitiesEvents { private readonly global::Windows.UI.Composition.CompositionCapabilities _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CompositionCapabilitiesEvents(global::Windows.UI.Composition.CompositionCapabilities data) + public RxCompositionCapabilitiesEvents(global::Windows.UI.Composition.CompositionCapabilities data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Composition.CompositionCapabilities sender, object args)> Changed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Composition.CompositionCapabilities sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Composition.CompositionCapabilities sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CompositionCommitBatchEvents + public class RxCompositionCommitBatchEvents { private readonly global::Windows.UI.Composition.CompositionCommitBatch _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CompositionCommitBatchEvents(global::Windows.UI.Composition.CompositionCommitBatch data) + public RxCompositionCommitBatchEvents(global::Windows.UI.Composition.CompositionCommitBatch data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CompositionGraphicsDeviceEvents + public class RxCompositionGraphicsDeviceEvents { private readonly global::Windows.UI.Composition.CompositionGraphicsDevice _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CompositionGraphicsDeviceEvents(global::Windows.UI.Composition.CompositionGraphicsDevice data) + public RxCompositionGraphicsDeviceEvents(global::Windows.UI.Composition.CompositionGraphicsDevice data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args)> RenderingDeviceReplaced => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RenderingDeviceReplaced += x, x => _data.RenderingDeviceReplaced -= x); + }, x => _data.RenderingDeviceReplaced += x, x => _data.RenderingDeviceReplaced -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CompositionScopedBatchEvents + public class RxCompositionScopedBatchEvents { private readonly global::Windows.UI.Composition.CompositionScopedBatch _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CompositionScopedBatchEvents(global::Windows.UI.Composition.CompositionScopedBatch data) + public RxCompositionScopedBatchEvents(global::Windows.UI.Composition.CompositionScopedBatch data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } } @@ -13467,34 +12227,32 @@ namespace Windows.UI.Composition.Core /// /// A wrapper class which wraps all the events contained within the class. /// - public static CompositorControllerEvents Events(this global::Windows.UI.Composition.Core.CompositorController item) => new CompositorControllerEvents(item); + public static RxCompositorControllerEvents Events(this global::Windows.UI.Composition.Core.CompositorController item) => new RxCompositorControllerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class CompositorControllerEvents + public class RxCompositorControllerEvents { private readonly global::Windows.UI.Composition.Core.CompositorController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CompositorControllerEvents(global::Windows.UI.Composition.Core.CompositorController data) + public RxCompositorControllerEvents(global::Windows.UI.Composition.Core.CompositorController data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Composition.Core.CompositorController sender, object args)> CommitNeeded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Composition.Core.CompositorController sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Composition.Core.CompositorController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CommitNeeded += x, x => _data.CommitNeeded -= x); + }, x => _data.CommitNeeded += x, x => _data.CommitNeeded -= x); } } @@ -13508,1014 +12266,858 @@ namespace Windows.UI.Core /// /// A wrapper class which wraps all the events contained within the class. /// - public static CoreAcceleratorKeysEvents Events(this global::Windows.UI.Core.CoreAcceleratorKeys item) => new CoreAcceleratorKeysEvents(item); + public static RxCoreAcceleratorKeysEvents Events(this global::Windows.UI.Core.CoreAcceleratorKeys item) => new RxCoreAcceleratorKeysEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CoreComponentInputSourceEvents Events(this global::Windows.UI.Core.CoreComponentInputSource item) => new CoreComponentInputSourceEvents(item); + public static RxCoreComponentInputSourceEvents Events(this global::Windows.UI.Core.CoreComponentInputSource item) => new RxCoreComponentInputSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CoreDispatcherEvents Events(this global::Windows.UI.Core.CoreDispatcher item) => new CoreDispatcherEvents(item); + public static RxCoreDispatcherEvents Events(this global::Windows.UI.Core.CoreDispatcher item) => new RxCoreDispatcherEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CoreIndependentInputSourceEvents Events(this global::Windows.UI.Core.CoreIndependentInputSource item) => new CoreIndependentInputSourceEvents(item); + public static RxCoreIndependentInputSourceEvents Events(this global::Windows.UI.Core.CoreIndependentInputSource item) => new RxCoreIndependentInputSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CoreWindowEvents Events(this global::Windows.UI.Core.CoreWindow item) => new CoreWindowEvents(item); + public static RxCoreWindowEvents Events(this global::Windows.UI.Core.CoreWindow item) => new RxCoreWindowEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ICoreAcceleratorKeysEvents Events(this global::Windows.UI.Core.ICoreAcceleratorKeys item) => new ICoreAcceleratorKeysEvents(item); + public static RxICoreAcceleratorKeysEvents Events(this global::Windows.UI.Core.ICoreAcceleratorKeys item) => new RxICoreAcceleratorKeysEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ICoreInputSourceBaseEvents Events(this global::Windows.UI.Core.ICoreInputSourceBase item) => new ICoreInputSourceBaseEvents(item); + public static RxICoreInputSourceBaseEvents Events(this global::Windows.UI.Core.ICoreInputSourceBase item) => new RxICoreInputSourceBaseEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ICorePointerInputSourceEvents Events(this global::Windows.UI.Core.ICorePointerInputSource item) => new ICorePointerInputSourceEvents(item); + public static RxICorePointerInputSourceEvents Events(this global::Windows.UI.Core.ICorePointerInputSource item) => new RxICorePointerInputSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ICorePointerRedirectorEvents Events(this global::Windows.UI.Core.ICorePointerRedirector item) => new ICorePointerRedirectorEvents(item); + public static RxICorePointerRedirectorEvents Events(this global::Windows.UI.Core.ICorePointerRedirector item) => new RxICorePointerRedirectorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ICoreWindowEvents Events(this global::Windows.UI.Core.ICoreWindow item) => new ICoreWindowEvents(item); + public static RxICoreWindowEvents Events(this global::Windows.UI.Core.ICoreWindow item) => new RxICoreWindowEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SystemNavigationManagerEvents Events(this global::Windows.UI.Core.SystemNavigationManager item) => new SystemNavigationManagerEvents(item); + public static RxSystemNavigationManagerEvents Events(this global::Windows.UI.Core.SystemNavigationManager item) => new RxSystemNavigationManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class CoreAcceleratorKeysEvents + public class RxCoreAcceleratorKeysEvents { private readonly global::Windows.UI.Core.CoreAcceleratorKeys _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CoreAcceleratorKeysEvents(global::Windows.UI.Core.CoreAcceleratorKeys data) + public RxCoreAcceleratorKeysEvents(global::Windows.UI.Core.CoreAcceleratorKeys data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)> AcceleratorKeyActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CoreComponentInputSourceEvents + public class RxCoreComponentInputSourceEvents { private readonly global::Windows.UI.Core.CoreComponentInputSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CoreComponentInputSourceEvents(global::Windows.UI.Core.CoreComponentInputSource data) + public RxCoreComponentInputSourceEvents(global::Windows.UI.Core.CoreComponentInputSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.CharacterReceivedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)> ClosestInteractiveBoundsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.CoreWindowEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.InputEnabledEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.KeyEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.KeyEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.CoreWindowEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable TouchHitTesting => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.TouchHitTestingEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CoreDispatcherEvents + public class RxCoreDispatcherEvents { private readonly global::Windows.UI.Core.CoreDispatcher _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CoreDispatcherEvents(global::Windows.UI.Core.CoreDispatcher data) + public RxCoreDispatcherEvents(global::Windows.UI.Core.CoreDispatcher data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)> AcceleratorKeyActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CoreIndependentInputSourceEvents + public class RxCoreIndependentInputSourceEvents { private readonly global::Windows.UI.Core.CoreIndependentInputSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CoreIndependentInputSourceEvents(global::Windows.UI.Core.CoreIndependentInputSource data) + public RxCoreIndependentInputSourceEvents(global::Windows.UI.Core.CoreIndependentInputSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.InputEnabledEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CoreWindowEvents + public class RxCoreWindowEvents { private readonly global::Windows.UI.Core.CoreWindow _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CoreWindowEvents(global::Windows.UI.Core.CoreWindow data) + public RxCoreWindowEvents(global::Windows.UI.Core.CoreWindow data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)> AutomationProviderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)> CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)> ClosestInteractiveBoundsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)> InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyDown => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyUp => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedAway => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedTo => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, object args)> ResizeCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResizeCompleted += x, x => _data.ResizeCompleted -= x); + }, x => _data.ResizeCompleted += x, x => _data.ResizeCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, object args)> ResizeStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResizeStarted += x, x => _data.ResizeStarted -= x); + }, x => _data.ResizeStarted += x, x => _data.ResizeStarted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)> SizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)> TouchHitTesting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)> VisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ICoreAcceleratorKeysEvents + public class RxICoreAcceleratorKeysEvents { private readonly global::Windows.UI.Core.ICoreAcceleratorKeys _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ICoreAcceleratorKeysEvents(global::Windows.UI.Core.ICoreAcceleratorKeys data) + public RxICoreAcceleratorKeysEvents(global::Windows.UI.Core.ICoreAcceleratorKeys data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)> AcceleratorKeyActivated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ICoreInputSourceBaseEvents + public class RxICoreInputSourceBaseEvents { private readonly global::Windows.UI.Core.ICoreInputSourceBase _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ICoreInputSourceBaseEvents(global::Windows.UI.Core.ICoreInputSourceBase data) + public RxICoreInputSourceBaseEvents(global::Windows.UI.Core.ICoreInputSourceBase data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.InputEnabledEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ICorePointerInputSourceEvents + public class RxICorePointerInputSourceEvents { private readonly global::Windows.UI.Core.ICorePointerInputSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ICorePointerInputSourceEvents(global::Windows.UI.Core.ICorePointerInputSource data) + public RxICorePointerInputSourceEvents(global::Windows.UI.Core.ICorePointerInputSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.PointerEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ICorePointerRedirectorEvents + public class RxICorePointerRedirectorEvents { private readonly global::Windows.UI.Core.ICorePointerRedirector _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ICorePointerRedirectorEvents(global::Windows.UI.Core.ICorePointerRedirector data) + public RxICorePointerRedirectorEvents(global::Windows.UI.Core.ICorePointerRedirector data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedAway => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)> PointerRoutedTo => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ICoreWindowEvents + public class RxICoreWindowEvents { private readonly global::Windows.UI.Core.ICoreWindow _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ICoreWindowEvents(global::Windows.UI.Core.ICoreWindow data) + public RxICoreWindowEvents(global::Windows.UI.Core.ICoreWindow data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)> AutomationProviderRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)> CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)> InputEnabled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyDown => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)> KeyUp => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)> PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)> SizeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)> TouchHitTesting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)> VisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SystemNavigationManagerEvents + public class RxSystemNavigationManagerEvents { private readonly global::Windows.UI.Core.SystemNavigationManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SystemNavigationManagerEvents(global::Windows.UI.Core.SystemNavigationManager data) + public RxSystemNavigationManagerEvents(global::Windows.UI.Core.SystemNavigationManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable BackRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.BackRequestedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.BackRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackRequested += x, x => _data.BackRequested -= x); + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); } } @@ -14529,34 +13131,32 @@ namespace Windows.UI.Core.Preview /// /// A wrapper class which wraps all the events contained within the class. /// - public static SystemNavigationManagerPreviewEvents Events(this global::Windows.UI.Core.Preview.SystemNavigationManagerPreview item) => new SystemNavigationManagerPreviewEvents(item); + public static RxSystemNavigationManagerPreviewEvents Events(this global::Windows.UI.Core.Preview.SystemNavigationManagerPreview item) => new RxSystemNavigationManagerPreviewEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class SystemNavigationManagerPreviewEvents + public class RxSystemNavigationManagerPreviewEvents { private readonly global::Windows.UI.Core.Preview.SystemNavigationManagerPreview _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SystemNavigationManagerPreviewEvents(global::Windows.UI.Core.Preview.SystemNavigationManagerPreview data) + public RxSystemNavigationManagerPreviewEvents(global::Windows.UI.Core.Preview.SystemNavigationManagerPreview data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable CloseRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Core.Preview.SystemNavigationCloseRequestedPreviewEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Core.Preview.SystemNavigationCloseRequestedPreviewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); } } @@ -14570,358 +13170,308 @@ namespace Windows.UI.Input /// /// A wrapper class which wraps all the events contained within the class. /// - public static EdgeGestureEvents Events(this global::Windows.UI.Input.EdgeGesture item) => new EdgeGestureEvents(item); + public static RxEdgeGestureEvents Events(this global::Windows.UI.Input.EdgeGesture item) => new RxEdgeGestureEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GestureRecognizerEvents Events(this global::Windows.UI.Input.GestureRecognizer item) => new GestureRecognizerEvents(item); + public static RxGestureRecognizerEvents Events(this global::Windows.UI.Input.GestureRecognizer item) => new RxGestureRecognizerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static KeyboardDeliveryInterceptorEvents Events(this global::Windows.UI.Input.KeyboardDeliveryInterceptor item) => new KeyboardDeliveryInterceptorEvents(item); + public static RxKeyboardDeliveryInterceptorEvents Events(this global::Windows.UI.Input.KeyboardDeliveryInterceptor item) => new RxKeyboardDeliveryInterceptorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RadialControllerEvents Events(this global::Windows.UI.Input.RadialController item) => new RadialControllerEvents(item); + public static RxRadialControllerEvents Events(this global::Windows.UI.Input.RadialController item) => new RxRadialControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RadialControllerMenuItemEvents Events(this global::Windows.UI.Input.RadialControllerMenuItem item) => new RadialControllerMenuItemEvents(item); + public static RxRadialControllerMenuItemEvents Events(this global::Windows.UI.Input.RadialControllerMenuItem item) => new RxRadialControllerMenuItemEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class EdgeGestureEvents + public class RxEdgeGestureEvents { private readonly global::Windows.UI.Input.EdgeGesture _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public EdgeGestureEvents(global::Windows.UI.Input.EdgeGesture data) + public RxEdgeGestureEvents(global::Windows.UI.Input.EdgeGesture data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)> Canceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)> Starting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Starting += x, x => _data.Starting -= x); + }, x => _data.Starting += x, x => _data.Starting -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GestureRecognizerEvents + public class RxGestureRecognizerEvents { private readonly global::Windows.UI.Input.GestureRecognizer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GestureRecognizerEvents(global::Windows.UI.Input.GestureRecognizer data) + public RxGestureRecognizerEvents(global::Windows.UI.Input.GestureRecognizer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args)> CrossSliding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CrossSliding += x, x => _data.CrossSliding -= x); + }, x => _data.CrossSliding += x, x => _data.CrossSliding -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args)> Dragging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Dragging += x, x => _data.Dragging -= x); + }, x => _data.Dragging += x, x => _data.Dragging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args)> Holding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Holding += x, x => _data.Holding -= x); + }, x => _data.Holding += x, x => _data.Holding -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args)> ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args)> ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args)> ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args)> ManipulationUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args)> RightTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RightTapped += x, x => _data.RightTapped -= x); + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args)> Tapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class KeyboardDeliveryInterceptorEvents + public class RxKeyboardDeliveryInterceptorEvents { private readonly global::Windows.UI.Input.KeyboardDeliveryInterceptor _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public KeyboardDeliveryInterceptorEvents(global::Windows.UI.Input.KeyboardDeliveryInterceptor data) + public RxKeyboardDeliveryInterceptorEvents(global::Windows.UI.Input.KeyboardDeliveryInterceptor data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)> KeyDown => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)> KeyUp => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RadialControllerEvents + public class RxRadialControllerEvents { private readonly global::Windows.UI.Input.RadialController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RadialControllerEvents(global::Windows.UI.Input.RadialController data) + public RxRadialControllerEvents(global::Windows.UI.Input.RadialController data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args)> ButtonClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonClicked += x, x => _data.ButtonClicked -= x); + }, x => _data.ButtonClicked += x, x => _data.ButtonClicked -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args)> ButtonHolding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonHolding += x, x => _data.ButtonHolding -= x); + }, x => _data.ButtonHolding += x, x => _data.ButtonHolding -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args)> ButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args)> ButtonReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonReleased += x, x => _data.ButtonReleased -= x); + }, x => _data.ButtonReleased += x, x => _data.ButtonReleased -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args)> ControlAcquired => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ControlAcquired += x, x => _data.ControlAcquired -= x); + }, x => _data.ControlAcquired += x, x => _data.ControlAcquired -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, object args)> ControlLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ControlLost += x, x => _data.ControlLost -= x); + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args)> RotationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RotationChanged += x, x => _data.RotationChanged -= x); + }, x => _data.RotationChanged += x, x => _data.RotationChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args)> ScreenContactContinued => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenContactContinued += x, x => _data.ScreenContactContinued -= x); + }, x => _data.ScreenContactContinued += x, x => _data.ScreenContactContinued -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, object args)> ScreenContactEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenContactEnded += x, x => _data.ScreenContactEnded -= x); + }, x => _data.ScreenContactEnded += x, x => _data.ScreenContactEnded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args)> ScreenContactStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenContactStarted += x, x => _data.ScreenContactStarted -= x); + }, x => _data.ScreenContactStarted += x, x => _data.ScreenContactStarted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RadialControllerMenuItemEvents + public class RxRadialControllerMenuItemEvents { private readonly global::Windows.UI.Input.RadialControllerMenuItem _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RadialControllerMenuItemEvents(global::Windows.UI.Input.RadialControllerMenuItem data) + public RxRadialControllerMenuItemEvents(global::Windows.UI.Input.RadialControllerMenuItem data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.RadialControllerMenuItem sender, object args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.RadialControllerMenuItem sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Input.RadialControllerMenuItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } } @@ -14935,196 +13485,170 @@ namespace Windows.UI.Input.Inking /// /// A wrapper class which wraps all the events contained within the class. /// - public static InkPresenterEvents Events(this global::Windows.UI.Input.Inking.InkPresenter item) => new InkPresenterEvents(item); + public static RxInkPresenterEvents Events(this global::Windows.UI.Input.Inking.InkPresenter item) => new RxInkPresenterEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static InkStrokeInputEvents Events(this global::Windows.UI.Input.Inking.InkStrokeInput item) => new InkStrokeInputEvents(item); + public static RxInkStrokeInputEvents Events(this global::Windows.UI.Input.Inking.InkStrokeInput item) => new RxInkStrokeInputEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static InkUnprocessedInputEvents Events(this global::Windows.UI.Input.Inking.InkUnprocessedInput item) => new InkUnprocessedInputEvents(item); + public static RxInkUnprocessedInputEvents Events(this global::Windows.UI.Input.Inking.InkUnprocessedInput item) => new RxInkUnprocessedInputEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class InkPresenterEvents + public class RxInkPresenterEvents { private readonly global::Windows.UI.Input.Inking.InkPresenter _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public InkPresenterEvents(global::Windows.UI.Input.Inking.InkPresenter data) + public RxInkPresenterEvents(global::Windows.UI.Input.Inking.InkPresenter data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args)> StrokesCollected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokesCollected += x, x => _data.StrokesCollected -= x); + }, x => _data.StrokesCollected += x, x => _data.StrokesCollected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args)> StrokesErased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokesErased += x, x => _data.StrokesErased -= x); + }, x => _data.StrokesErased += x, x => _data.StrokesErased -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class InkStrokeInputEvents + public class RxInkStrokeInputEvents { private readonly global::Windows.UI.Input.Inking.InkStrokeInput _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public InkStrokeInputEvents(global::Windows.UI.Input.Inking.InkStrokeInput data) + public RxInkStrokeInputEvents(global::Windows.UI.Input.Inking.InkStrokeInput data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeCanceled += x, x => _data.StrokeCanceled -= x); + }, x => _data.StrokeCanceled += x, x => _data.StrokeCanceled -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeContinued => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeContinued += x, x => _data.StrokeContinued -= x); + }, x => _data.StrokeContinued += x, x => _data.StrokeContinued -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeEnded += x, x => _data.StrokeEnded -= x); + }, x => _data.StrokeEnded += x, x => _data.StrokeEnded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)> StrokeStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeStarted += x, x => _data.StrokeStarted -= x); + }, x => _data.StrokeStarted += x, x => _data.StrokeStarted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class InkUnprocessedInputEvents + public class RxInkUnprocessedInputEvents { private readonly global::Windows.UI.Input.Inking.InkUnprocessedInput _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public InkUnprocessedInputEvents(global::Windows.UI.Input.Inking.InkUnprocessedInput data) + public RxInkUnprocessedInputEvents(global::Windows.UI.Input.Inking.InkUnprocessedInput data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerHovered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerHovered += x, x => _data.PointerHovered -= x); + }, x => _data.PointerHovered += x, x => _data.PointerHovered -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerLost += x, x => _data.PointerLost -= x); + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); } } @@ -15138,165 +13662,141 @@ namespace Windows.UI.Input.Inking.Core /// /// A wrapper class which wraps all the events contained within the class. /// - public static CoreInkIndependentInputSourceEvents Events(this global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource item) => new CoreInkIndependentInputSourceEvents(item); + public static RxCoreInkIndependentInputSourceEvents Events(this global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource item) => new RxCoreInkIndependentInputSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CoreWetStrokeUpdateSourceEvents Events(this global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource item) => new CoreWetStrokeUpdateSourceEvents(item); + public static RxCoreWetStrokeUpdateSourceEvents Events(this global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource item) => new RxCoreWetStrokeUpdateSourceEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class CoreInkIndependentInputSourceEvents + public class RxCoreInkIndependentInputSourceEvents { private readonly global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CoreInkIndependentInputSourceEvents(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource data) + public RxCoreInkIndependentInputSourceEvents(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerEntering => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntering += x, x => _data.PointerEntering -= x); + }, x => _data.PointerEntering += x, x => _data.PointerEntering -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerExiting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExiting += x, x => _data.PointerExiting -= x); + }, x => _data.PointerExiting += x, x => _data.PointerExiting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerHovering => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerHovering += x, x => _data.PointerHovering -= x); + }, x => _data.PointerHovering += x, x => _data.PointerHovering -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerLost += x, x => _data.PointerLost -= x); + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerMoving => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoving += x, x => _data.PointerMoving -= x); + }, x => _data.PointerMoving += x, x => _data.PointerMoving -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerPressing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressing += x, x => _data.PointerPressing -= x); + }, x => _data.PointerPressing += x, x => _data.PointerPressing -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)> PointerReleasing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleasing += x, x => _data.PointerReleasing -= x); + }, x => _data.PointerReleasing += x, x => _data.PointerReleasing -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CoreWetStrokeUpdateSourceEvents + public class RxCoreWetStrokeUpdateSourceEvents { private readonly global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CoreWetStrokeUpdateSourceEvents(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource data) + public RxCoreWetStrokeUpdateSourceEvents(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeCanceled += x, x => _data.WetStrokeCanceled -= x); + }, x => _data.WetStrokeCanceled += x, x => _data.WetStrokeCanceled -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeCompleted += x, x => _data.WetStrokeCompleted -= x); + }, x => _data.WetStrokeCompleted += x, x => _data.WetStrokeCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeContinuing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeContinuing += x, x => _data.WetStrokeContinuing -= x); + }, x => _data.WetStrokeContinuing += x, x => _data.WetStrokeContinuing -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeStarting += x, x => _data.WetStrokeStarting -= x); + }, x => _data.WetStrokeStarting += x, x => _data.WetStrokeStarting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)> WetStrokeStopping => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeStopping += x, x => _data.WetStrokeStopping -= x); + }, x => _data.WetStrokeStopping += x, x => _data.WetStrokeStopping -= x); } } @@ -15310,245 +13810,205 @@ namespace Windows.UI.Input.Spatial /// /// A wrapper class which wraps all the events contained within the class. /// - public static SpatialGestureRecognizerEvents Events(this global::Windows.UI.Input.Spatial.SpatialGestureRecognizer item) => new SpatialGestureRecognizerEvents(item); + public static RxSpatialGestureRecognizerEvents Events(this global::Windows.UI.Input.Spatial.SpatialGestureRecognizer item) => new RxSpatialGestureRecognizerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SpatialInteractionManagerEvents Events(this global::Windows.UI.Input.Spatial.SpatialInteractionManager item) => new SpatialInteractionManagerEvents(item); + public static RxSpatialInteractionManagerEvents Events(this global::Windows.UI.Input.Spatial.SpatialInteractionManager item) => new RxSpatialInteractionManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class SpatialGestureRecognizerEvents + public class RxSpatialGestureRecognizerEvents { private readonly global::Windows.UI.Input.Spatial.SpatialGestureRecognizer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SpatialGestureRecognizerEvents(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer data) + public RxSpatialGestureRecognizerEvents(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args)> HoldCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HoldCanceled += x, x => _data.HoldCanceled -= x); + }, x => _data.HoldCanceled += x, x => _data.HoldCanceled -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args)> HoldCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HoldCompleted += x, x => _data.HoldCompleted -= x); + }, x => _data.HoldCompleted += x, x => _data.HoldCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args)> HoldStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HoldStarted += x, x => _data.HoldStarted -= x); + }, x => _data.HoldStarted += x, x => _data.HoldStarted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args)> ManipulationCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationCanceled += x, x => _data.ManipulationCanceled -= x); + }, x => _data.ManipulationCanceled += x, x => _data.ManipulationCanceled -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args)> ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args)> ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args)> ManipulationUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args)> NavigationCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCanceled += x, x => _data.NavigationCanceled -= x); + }, x => _data.NavigationCanceled += x, x => _data.NavigationCanceled -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args)> NavigationStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarted += x, x => _data.NavigationStarted -= x); + }, x => _data.NavigationStarted += x, x => _data.NavigationStarted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args)> NavigationUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationUpdated += x, x => _data.NavigationUpdated -= x); + }, x => _data.NavigationUpdated += x, x => _data.NavigationUpdated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args)> RecognitionEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RecognitionEnded += x, x => _data.RecognitionEnded -= x); + }, x => _data.RecognitionEnded += x, x => _data.RecognitionEnded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args)> RecognitionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RecognitionStarted += x, x => _data.RecognitionStarted -= x); + }, x => _data.RecognitionStarted += x, x => _data.RecognitionStarted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args)> Tapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SpatialInteractionManagerEvents + public class RxSpatialInteractionManagerEvents { private readonly global::Windows.UI.Input.Spatial.SpatialInteractionManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SpatialInteractionManagerEvents(global::Windows.UI.Input.Spatial.SpatialInteractionManager data) + public RxSpatialInteractionManagerEvents(global::Windows.UI.Input.Spatial.SpatialInteractionManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args)> InteractionDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InteractionDetected += x, x => _data.InteractionDetected -= x); + }, x => _data.InteractionDetected += x, x => _data.InteractionDetected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceDetected += x, x => _data.SourceDetected -= x); + }, x => _data.SourceDetected += x, x => _data.SourceDetected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceLost += x, x => _data.SourceLost -= x); + }, x => _data.SourceLost += x, x => _data.SourceLost -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourcePressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourcePressed += x, x => _data.SourcePressed -= x); + }, x => _data.SourcePressed += x, x => _data.SourcePressed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceReleased => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceReleased += x, x => _data.SourceReleased -= x); + }, x => _data.SourceReleased += x, x => _data.SourceReleased -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)> SourceUpdated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); } } @@ -15562,85 +14022,77 @@ namespace Windows.UI.Notifications /// /// A wrapper class which wraps all the events contained within the class. /// - public static ToastNotificationEvents Events(this global::Windows.UI.Notifications.ToastNotification item) => new ToastNotificationEvents(item); + public static RxToastNotificationEvents Events(this global::Windows.UI.Notifications.ToastNotification item) => new RxToastNotificationEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ToastNotifierEvents Events(this global::Windows.UI.Notifications.ToastNotifier item) => new ToastNotifierEvents(item); + public static RxToastNotifierEvents Events(this global::Windows.UI.Notifications.ToastNotifier item) => new RxToastNotifierEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ToastNotificationEvents + public class RxToastNotificationEvents { private readonly global::Windows.UI.Notifications.ToastNotification _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ToastNotificationEvents(global::Windows.UI.Notifications.ToastNotification data) + public RxToastNotificationEvents(global::Windows.UI.Notifications.ToastNotification data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotification sender, object args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotification sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Notifications.ToastNotification sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args)> Dismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args)> Failed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Failed += x, x => _data.Failed -= x); + }, x => _data.Failed += x, x => _data.Failed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ToastNotifierEvents + public class RxToastNotifierEvents { private readonly global::Windows.UI.Notifications.ToastNotifier _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ToastNotifierEvents(global::Windows.UI.Notifications.ToastNotifier data) + public RxToastNotifierEvents(global::Windows.UI.Notifications.ToastNotifier data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args)> ScheduledToastNotificationShowing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScheduledToastNotificationShowing += x, x => _data.ScheduledToastNotificationShowing -= x); + }, x => _data.ScheduledToastNotificationShowing += x, x => _data.ScheduledToastNotificationShowing -= x); } } @@ -15654,34 +14106,32 @@ namespace Windows.UI.Notifications.Management /// /// A wrapper class which wraps all the events contained within the class. /// - public static UserNotificationListenerEvents Events(this global::Windows.UI.Notifications.Management.UserNotificationListener item) => new UserNotificationListenerEvents(item); + public static RxUserNotificationListenerEvents Events(this global::Windows.UI.Notifications.Management.UserNotificationListener item) => new RxUserNotificationListenerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class UserNotificationListenerEvents + public class RxUserNotificationListenerEvents { private readonly global::Windows.UI.Notifications.Management.UserNotificationListener _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public UserNotificationListenerEvents(global::Windows.UI.Notifications.Management.UserNotificationListener data) + public RxUserNotificationListenerEvents(global::Windows.UI.Notifications.Management.UserNotificationListener data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args)> NotificationChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NotificationChanged += x, x => _data.NotificationChanged -= x); + }, x => _data.NotificationChanged += x, x => _data.NotificationChanged -= x); } } @@ -15695,34 +14145,32 @@ namespace Windows.UI.StartScreen /// /// A wrapper class which wraps all the events contained within the class. /// - public static SecondaryTileEvents Events(this global::Windows.UI.StartScreen.SecondaryTile item) => new SecondaryTileEvents(item); + public static RxSecondaryTileEvents Events(this global::Windows.UI.StartScreen.SecondaryTile item) => new RxSecondaryTileEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class SecondaryTileEvents + public class RxSecondaryTileEvents { private readonly global::Windows.UI.StartScreen.SecondaryTile _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SecondaryTileEvents(global::Windows.UI.StartScreen.SecondaryTile data) + public RxSecondaryTileEvents(global::Windows.UI.StartScreen.SecondaryTile data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args)> VisualElementsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisualElementsRequested += x, x => _data.VisualElementsRequested -= x); + }, x => _data.VisualElementsRequested += x, x => _data.VisualElementsRequested -= x); } } @@ -15736,155 +14184,133 @@ namespace Windows.UI.Text.Core /// /// A wrapper class which wraps all the events contained within the class. /// - public static CoreTextEditContextEvents Events(this global::Windows.UI.Text.Core.CoreTextEditContext item) => new CoreTextEditContextEvents(item); + public static RxCoreTextEditContextEvents Events(this global::Windows.UI.Text.Core.CoreTextEditContext item) => new RxCoreTextEditContextEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CoreTextServicesManagerEvents Events(this global::Windows.UI.Text.Core.CoreTextServicesManager item) => new CoreTextServicesManagerEvents(item); + public static RxCoreTextServicesManagerEvents Events(this global::Windows.UI.Text.Core.CoreTextServicesManager item) => new RxCoreTextServicesManagerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class CoreTextEditContextEvents + public class RxCoreTextEditContextEvents { private readonly global::Windows.UI.Text.Core.CoreTextEditContext _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CoreTextEditContextEvents(global::Windows.UI.Text.Core.CoreTextEditContext data) + public RxCoreTextEditContextEvents(global::Windows.UI.Text.Core.CoreTextEditContext data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args)> CompositionCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompositionCompleted += x, x => _data.CompositionCompleted -= x); + }, x => _data.CompositionCompleted += x, x => _data.CompositionCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args)> CompositionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompositionStarted += x, x => _data.CompositionStarted -= x); + }, x => _data.CompositionStarted += x, x => _data.CompositionStarted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)> FocusRemoved => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusRemoved += x, x => _data.FocusRemoved -= x); + }, x => _data.FocusRemoved += x, x => _data.FocusRemoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args)> FormatUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FormatUpdating += x, x => _data.FormatUpdating -= x); + }, x => _data.FormatUpdating += x, x => _data.FormatUpdating -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args)> LayoutRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LayoutRequested += x, x => _data.LayoutRequested -= x); + }, x => _data.LayoutRequested += x, x => _data.LayoutRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)> NotifyFocusLeaveCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NotifyFocusLeaveCompleted += x, x => _data.NotifyFocusLeaveCompleted -= x); + }, x => _data.NotifyFocusLeaveCompleted += x, x => _data.NotifyFocusLeaveCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args)> SelectionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionRequested += x, x => _data.SelectionRequested -= x); + }, x => _data.SelectionRequested += x, x => _data.SelectionRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args)> SelectionUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionUpdating += x, x => _data.SelectionUpdating -= x); + }, x => _data.SelectionUpdating += x, x => _data.SelectionUpdating -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args)> TextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextRequested += x, x => _data.TextRequested -= x); + }, x => _data.TextRequested += x, x => _data.TextRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args)> TextUpdating => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextUpdating += x, x => _data.TextUpdating -= x); + }, x => _data.TextUpdating += x, x => _data.TextUpdating -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CoreTextServicesManagerEvents + public class RxCoreTextServicesManagerEvents { private readonly global::Windows.UI.Text.Core.CoreTextServicesManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CoreTextServicesManagerEvents(global::Windows.UI.Text.Core.CoreTextServicesManager data) + public RxCoreTextServicesManagerEvents(global::Windows.UI.Text.Core.CoreTextServicesManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args)> InputLanguageChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); } } @@ -15898,208 +14324,188 @@ namespace Windows.UI.ViewManagement /// /// A wrapper class which wraps all the events contained within the class. /// - public static AccessibilitySettingsEvents Events(this global::Windows.UI.ViewManagement.AccessibilitySettings item) => new AccessibilitySettingsEvents(item); + public static RxAccessibilitySettingsEvents Events(this global::Windows.UI.ViewManagement.AccessibilitySettings item) => new RxAccessibilitySettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ApplicationViewEvents Events(this global::Windows.UI.ViewManagement.ApplicationView item) => new ApplicationViewEvents(item); + public static RxApplicationViewEvents Events(this global::Windows.UI.ViewManagement.ApplicationView item) => new RxApplicationViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static InputPaneEvents Events(this global::Windows.UI.ViewManagement.InputPane item) => new InputPaneEvents(item); + public static RxInputPaneEvents Events(this global::Windows.UI.ViewManagement.InputPane item) => new RxInputPaneEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static StatusBarEvents Events(this global::Windows.UI.ViewManagement.StatusBar item) => new StatusBarEvents(item); + public static RxStatusBarEvents Events(this global::Windows.UI.ViewManagement.StatusBar item) => new RxStatusBarEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static UISettingsEvents Events(this global::Windows.UI.ViewManagement.UISettings item) => new UISettingsEvents(item); + public static RxUISettingsEvents Events(this global::Windows.UI.ViewManagement.UISettings item) => new RxUISettingsEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AccessibilitySettingsEvents + public class RxAccessibilitySettingsEvents { private readonly global::Windows.UI.ViewManagement.AccessibilitySettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AccessibilitySettingsEvents(global::Windows.UI.ViewManagement.AccessibilitySettings data) + public RxAccessibilitySettingsEvents(global::Windows.UI.ViewManagement.AccessibilitySettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args)> HighContrastChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args)>(eventHandler => { void Handler(global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HighContrastChanged += x, x => _data.HighContrastChanged -= x); + }, x => _data.HighContrastChanged += x, x => _data.HighContrastChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ApplicationViewEvents + public class RxApplicationViewEvents { private readonly global::Windows.UI.ViewManagement.ApplicationView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ApplicationViewEvents(global::Windows.UI.ViewManagement.ApplicationView data) + public RxApplicationViewEvents(global::Windows.UI.ViewManagement.ApplicationView data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args)> Consolidated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Consolidated += x, x => _data.Consolidated -= x); + }, x => _data.Consolidated += x, x => _data.Consolidated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.ViewManagement.ApplicationView sender, object args)> VisibleBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.ApplicationView sender, object args)>(eventHandler => { void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisibleBoundsChanged += x, x => _data.VisibleBoundsChanged -= x); + }, x => _data.VisibleBoundsChanged += x, x => _data.VisibleBoundsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class InputPaneEvents + public class RxInputPaneEvents { private readonly global::Windows.UI.ViewManagement.InputPane _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public InputPaneEvents(global::Windows.UI.ViewManagement.InputPane data) + public RxInputPaneEvents(global::Windows.UI.ViewManagement.InputPane data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)> Hiding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Hiding += x, x => _data.Hiding -= x); + }, x => _data.Hiding += x, x => _data.Hiding -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)> Showing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Showing += x, x => _data.Showing -= x); + }, x => _data.Showing += x, x => _data.Showing -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class StatusBarEvents + public class RxStatusBarEvents { private readonly global::Windows.UI.ViewManagement.StatusBar _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public StatusBarEvents(global::Windows.UI.ViewManagement.StatusBar data) + public RxStatusBarEvents(global::Windows.UI.ViewManagement.StatusBar data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.ViewManagement.StatusBar sender, object args)> Hiding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.StatusBar sender, object args)>(eventHandler => { void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Hiding += x, x => _data.Hiding -= x); + }, x => _data.Hiding += x, x => _data.Hiding -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.ViewManagement.StatusBar sender, object args)> Showing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.StatusBar sender, object args)>(eventHandler => { void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Showing += x, x => _data.Showing -= x); + }, x => _data.Showing += x, x => _data.Showing -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class UISettingsEvents + public class RxUISettingsEvents { private readonly global::Windows.UI.ViewManagement.UISettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public UISettingsEvents(global::Windows.UI.ViewManagement.UISettings data) + public RxUISettingsEvents(global::Windows.UI.ViewManagement.UISettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, object args)> AdvancedEffectsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, object args)>(eventHandler => { void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvancedEffectsEnabledChanged += x, x => _data.AdvancedEffectsEnabledChanged -= x); + }, x => _data.AdvancedEffectsEnabledChanged += x, x => _data.AdvancedEffectsEnabledChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, object args)> ColorValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, object args)>(eventHandler => { void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorValuesChanged += x, x => _data.ColorValuesChanged -= x); + }, x => _data.ColorValuesChanged += x, x => _data.ColorValuesChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.ViewManagement.UISettings sender, object args)> TextScaleFactorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.UISettings sender, object args)>(eventHandler => { void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextScaleFactorChanged += x, x => _data.TextScaleFactorChanged -= x); + }, x => _data.TextScaleFactorChanged += x, x => _data.TextScaleFactorChanged -= x); } } @@ -16113,54 +14519,48 @@ namespace Windows.UI.ViewManagement.Core /// /// A wrapper class which wraps all the events contained within the class. /// - public static CoreInputViewEvents Events(this global::Windows.UI.ViewManagement.Core.CoreInputView item) => new CoreInputViewEvents(item); + public static RxCoreInputViewEvents Events(this global::Windows.UI.ViewManagement.Core.CoreInputView item) => new RxCoreInputViewEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class CoreInputViewEvents + public class RxCoreInputViewEvents { private readonly global::Windows.UI.ViewManagement.Core.CoreInputView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CoreInputViewEvents(global::Windows.UI.ViewManagement.Core.CoreInputView data) + public RxCoreInputViewEvents(global::Windows.UI.ViewManagement.Core.CoreInputView data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args)> OcclusionsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OcclusionsChanged += x, x => _data.OcclusionsChanged -= x); + }, x => _data.OcclusionsChanged += x, x => _data.OcclusionsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args)> XYFocusTransferredToPrimaryView => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args)>(eventHandler => { void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.XYFocusTransferredToPrimaryView += x, x => _data.XYFocusTransferredToPrimaryView -= x); + }, x => _data.XYFocusTransferredToPrimaryView += x, x => _data.XYFocusTransferredToPrimaryView -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args)> XYFocusTransferringFromPrimaryView => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.XYFocusTransferringFromPrimaryView += x, x => _data.XYFocusTransferringFromPrimaryView -= x); + }, x => _data.XYFocusTransferringFromPrimaryView += x, x => _data.XYFocusTransferringFromPrimaryView -= x); } } @@ -16174,245 +14574,205 @@ namespace Windows.UI.WebUI /// /// A wrapper class which wraps all the events contained within the class. /// - public static WebUIBackgroundTaskInstanceRuntimeClassEvents Events(this global::Windows.UI.WebUI.WebUIBackgroundTaskInstanceRuntimeClass item) => new WebUIBackgroundTaskInstanceRuntimeClassEvents(item); + public static RxWebUIBackgroundTaskInstanceRuntimeClassEvents Events(this global::Windows.UI.WebUI.WebUIBackgroundTaskInstanceRuntimeClass item) => new RxWebUIBackgroundTaskInstanceRuntimeClassEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static WebUIViewEvents Events(this global::Windows.UI.WebUI.WebUIView item) => new WebUIViewEvents(item); + public static RxWebUIViewEvents Events(this global::Windows.UI.WebUI.WebUIView item) => new RxWebUIViewEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class WebUIBackgroundTaskInstanceRuntimeClassEvents + public class RxWebUIBackgroundTaskInstanceRuntimeClassEvents { private readonly global::Windows.UI.WebUI.WebUIBackgroundTaskInstanceRuntimeClass _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WebUIBackgroundTaskInstanceRuntimeClassEvents(global::Windows.UI.WebUI.WebUIBackgroundTaskInstanceRuntimeClass data) + public RxWebUIBackgroundTaskInstanceRuntimeClassEvents(global::Windows.UI.WebUI.WebUIBackgroundTaskInstanceRuntimeClass data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason)> Canceled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class WebUIViewEvents + public class RxWebUIViewEvents { private readonly global::Windows.UI.WebUI.WebUIView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WebUIViewEvents(global::Windows.UI.WebUI.WebUIView data) + public RxWebUIViewEvents(global::Windows.UI.WebUI.WebUIView data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)> Activated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.WebUI.WebUIView sender, object args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.WebUI.WebUIView sender, object args)>(eventHandler => { void Handler(global::Windows.UI.WebUI.WebUIView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)> ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } } @@ -16426,1244 +14786,1084 @@ namespace Windows.UI.Xaml /// /// A wrapper class which wraps all the events contained within the class. /// - public static ApplicationEvents Events(this global::Windows.UI.Xaml.Application item) => new ApplicationEvents(item); + public static RxApplicationEvents Events(this global::Windows.UI.Xaml.Application item) => new RxApplicationEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AttachedDependencyObjectEvents Events(this global::Windows.UI.Xaml.AttachedDependencyObject item) => new AttachedDependencyObjectEvents(item); + public static RxAttachedDependencyObjectEvents Events(this global::Windows.UI.Xaml.AttachedDependencyObject item) => new RxAttachedDependencyObjectEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DebugSettingsEvents Events(this global::Windows.UI.Xaml.DebugSettings item) => new DebugSettingsEvents(item); + public static RxDebugSettingsEvents Events(this global::Windows.UI.Xaml.DebugSettings item) => new RxDebugSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DependencyObjectCollectionBaseEvents Events(this global::Windows.UI.Xaml.DependencyObjectCollectionBase item) => new DependencyObjectCollectionBaseEvents(item); + public static RxDependencyObjectCollectionBaseEvents Events(this global::Windows.UI.Xaml.DependencyObjectCollectionBase item) => new RxDependencyObjectCollectionBaseEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DispatcherTimerEvents Events(this global::Windows.UI.Xaml.DispatcherTimer item) => new DispatcherTimerEvents(item); + public static RxDispatcherTimerEvents Events(this global::Windows.UI.Xaml.DispatcherTimer item) => new RxDispatcherTimerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static FrameworkElementEvents Events(this global::Windows.UI.Xaml.FrameworkElement item) => new FrameworkElementEvents(item); + public static RxFrameworkElementEvents Events(this global::Windows.UI.Xaml.FrameworkElement item) => new RxFrameworkElementEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static FrameworkTemplateEvents Events(this global::Windows.UI.Xaml.FrameworkTemplate item) => new FrameworkTemplateEvents(item); + public static RxFrameworkTemplateEvents Events(this global::Windows.UI.Xaml.FrameworkTemplate item) => new RxFrameworkTemplateEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IFrameworkElementEvents Events(this global::Windows.UI.Xaml.IFrameworkElement item) => new IFrameworkElementEvents(item); + public static RxIFrameworkElementEvents Events(this global::Windows.UI.Xaml.IFrameworkElement item) => new RxIFrameworkElementEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PropertyPathEvents Events(this global::Windows.UI.Xaml.PropertyPath item) => new PropertyPathEvents(item); + public static RxPropertyPathEvents Events(this global::Windows.UI.Xaml.PropertyPath item) => new RxPropertyPathEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ResourceDictionaryEvents Events(this global::Windows.UI.Xaml.ResourceDictionary item) => new ResourceDictionaryEvents(item); + public static RxResourceDictionaryEvents Events(this global::Windows.UI.Xaml.ResourceDictionary item) => new RxResourceDictionaryEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SetterBaseEvents Events(this global::Windows.UI.Xaml.SetterBase item) => new SetterBaseEvents(item); + public static RxSetterBaseEvents Events(this global::Windows.UI.Xaml.SetterBase item) => new RxSetterBaseEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static StateTriggerBaseEvents Events(this global::Windows.UI.Xaml.StateTriggerBase item) => new StateTriggerBaseEvents(item); + public static RxStateTriggerBaseEvents Events(this global::Windows.UI.Xaml.StateTriggerBase item) => new RxStateTriggerBaseEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static StyleEvents Events(this global::Windows.UI.Xaml.Style item) => new StyleEvents(item); + public static RxStyleEvents Events(this global::Windows.UI.Xaml.Style item) => new RxStyleEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TriggerActionEvents Events(this global::Windows.UI.Xaml.TriggerAction item) => new TriggerActionEvents(item); + public static RxTriggerActionEvents Events(this global::Windows.UI.Xaml.TriggerAction item) => new RxTriggerActionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TriggerBaseEvents Events(this global::Windows.UI.Xaml.TriggerBase item) => new TriggerBaseEvents(item); + public static RxTriggerBaseEvents Events(this global::Windows.UI.Xaml.TriggerBase item) => new RxTriggerBaseEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static UIElementEvents Events(this global::Windows.UI.Xaml.UIElement item) => new UIElementEvents(item); + public static RxUIElementEvents Events(this global::Windows.UI.Xaml.UIElement item) => new RxUIElementEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static VisualStateEvents Events(this global::Windows.UI.Xaml.VisualState item) => new VisualStateEvents(item); + public static RxVisualStateEvents Events(this global::Windows.UI.Xaml.VisualState item) => new RxVisualStateEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static VisualStateGroupEvents Events(this global::Windows.UI.Xaml.VisualStateGroup item) => new VisualStateGroupEvents(item); + public static RxVisualStateGroupEvents Events(this global::Windows.UI.Xaml.VisualStateGroup item) => new RxVisualStateGroupEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static VisualStateManagerEvents Events(this global::Windows.UI.Xaml.VisualStateManager item) => new VisualStateManagerEvents(item); + public static RxVisualStateManagerEvents Events(this global::Windows.UI.Xaml.VisualStateManager item) => new RxVisualStateManagerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static VisualTransitionEvents Events(this global::Windows.UI.Xaml.VisualTransition item) => new VisualTransitionEvents(item); + public static RxVisualTransitionEvents Events(this global::Windows.UI.Xaml.VisualTransition item) => new RxVisualTransitionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static WindowEvents Events(this global::Windows.UI.Xaml.Window item) => new WindowEvents(item); + public static RxWindowEvents Events(this global::Windows.UI.Xaml.Window item) => new RxWindowEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ApplicationEvents + public class RxApplicationEvents { private readonly global::Windows.UI.Xaml.Application _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ApplicationEvents(global::Windows.UI.Xaml.Application data) + public RxApplicationEvents(global::Windows.UI.Xaml.Application data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable EnteredBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EnteredBackground += x, x => _data.EnteredBackground -= x); + }, x => _data.EnteredBackground += x, x => _data.EnteredBackground -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable LeavingBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LeavingBackground += x, x => _data.LeavingBackground -= x); + }, x => _data.LeavingBackground += x, x => _data.LeavingBackground -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Resuming => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Resuming += x, x => _data.Resuming -= x); + }, x => _data.Resuming += x, x => _data.Resuming -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Suspending => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Suspending += x, x => _data.Suspending -= x); + }, x => _data.Suspending += x, x => _data.Suspending -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable UnhandledException => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.UnhandledExceptionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AttachedDependencyObjectEvents + public class RxAttachedDependencyObjectEvents { private readonly global::Windows.UI.Xaml.AttachedDependencyObject _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AttachedDependencyObjectEvents(global::Windows.UI.Xaml.AttachedDependencyObject data) + public RxAttachedDependencyObjectEvents(global::Windows.UI.Xaml.AttachedDependencyObject data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DebugSettingsEvents + public class RxDebugSettingsEvents { private readonly global::Windows.UI.Xaml.DebugSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DebugSettingsEvents(global::Windows.UI.Xaml.DebugSettings data) + public RxDebugSettingsEvents(global::Windows.UI.Xaml.DebugSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable BindingFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.BindingFailedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingFailed += x, x => _data.BindingFailed -= x); + }, x => _data.BindingFailed += x, x => _data.BindingFailed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DependencyObjectCollectionBaseEvents + public class RxDependencyObjectCollectionBaseEvents { private readonly global::Windows.UI.Xaml.DependencyObjectCollectionBase _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DependencyObjectCollectionBaseEvents(global::Windows.UI.Xaml.DependencyObjectCollectionBase data) + public RxDependencyObjectCollectionBaseEvents(global::Windows.UI.Xaml.DependencyObjectCollectionBase data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DispatcherTimerEvents + public class RxDispatcherTimerEvents { private readonly global::Windows.UI.Xaml.DispatcherTimer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DispatcherTimerEvents(global::Windows.UI.Xaml.DispatcherTimer data) + public RxDispatcherTimerEvents(global::Windows.UI.Xaml.DispatcherTimer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Tick => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class FrameworkElementEvents + public class RxFrameworkElementEvents : global::Windows.UI.Xaml.RxUIElementEvents { private readonly global::Windows.UI.Xaml.FrameworkElement _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public FrameworkElementEvents(global::Windows.UI.Xaml.FrameworkElement data) + public RxFrameworkElementEvents(global::Windows.UI.Xaml.FrameworkElement data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.FrameworkElement sender, object args)> ActualThemeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.FrameworkElement sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.FrameworkElement sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActualThemeChanged += x, x => _data.ActualThemeChanged -= x); + }, x => _data.ActualThemeChanged += x, x => _data.ActualThemeChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args)> EffectiveViewportChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EffectiveViewportChanged += x, x => _data.EffectiveViewportChanged -= x); + }, x => _data.EffectiveViewportChanged += x, x => _data.EffectiveViewportChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable IsEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Loading => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class FrameworkTemplateEvents + public class RxFrameworkTemplateEvents { private readonly global::Windows.UI.Xaml.FrameworkTemplate _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public FrameworkTemplateEvents(global::Windows.UI.Xaml.FrameworkTemplate data) + public RxFrameworkTemplateEvents(global::Windows.UI.Xaml.FrameworkTemplate data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IFrameworkElementEvents + public class RxIFrameworkElementEvents { private readonly global::Windows.UI.Xaml.IFrameworkElement _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IFrameworkElementEvents(global::Windows.UI.Xaml.IFrameworkElement data) + public RxIFrameworkElementEvents(global::Windows.UI.Xaml.IFrameworkElement data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Loaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Unloaded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PropertyPathEvents + public class RxPropertyPathEvents { private readonly global::Windows.UI.Xaml.PropertyPath _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PropertyPathEvents(global::Windows.UI.Xaml.PropertyPath data) + public RxPropertyPathEvents(global::Windows.UI.Xaml.PropertyPath data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ResourceDictionaryEvents + public class RxResourceDictionaryEvents { private readonly global::Windows.UI.Xaml.ResourceDictionary _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ResourceDictionaryEvents(global::Windows.UI.Xaml.ResourceDictionary data) + public RxResourceDictionaryEvents(global::Windows.UI.Xaml.ResourceDictionary data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SetterBaseEvents + public class RxSetterBaseEvents { private readonly global::Windows.UI.Xaml.SetterBase _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SetterBaseEvents(global::Windows.UI.Xaml.SetterBase data) + public RxSetterBaseEvents(global::Windows.UI.Xaml.SetterBase data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class StateTriggerBaseEvents + public class RxStateTriggerBaseEvents { private readonly global::Windows.UI.Xaml.StateTriggerBase _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public StateTriggerBaseEvents(global::Windows.UI.Xaml.StateTriggerBase data) + public RxStateTriggerBaseEvents(global::Windows.UI.Xaml.StateTriggerBase data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class StyleEvents + public class RxStyleEvents { private readonly global::Windows.UI.Xaml.Style _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public StyleEvents(global::Windows.UI.Xaml.Style data) + public RxStyleEvents(global::Windows.UI.Xaml.Style data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TriggerActionEvents + public class RxTriggerActionEvents { private readonly global::Windows.UI.Xaml.TriggerAction _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TriggerActionEvents(global::Windows.UI.Xaml.TriggerAction data) + public RxTriggerActionEvents(global::Windows.UI.Xaml.TriggerAction data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TriggerBaseEvents + public class RxTriggerBaseEvents { private readonly global::Windows.UI.Xaml.TriggerBase _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TriggerBaseEvents(global::Windows.UI.Xaml.TriggerBase data) + public RxTriggerBaseEvents(global::Windows.UI.Xaml.TriggerBase data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class UIElementEvents + public class RxUIElementEvents { private readonly global::Windows.UI.Xaml.UIElement _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public UIElementEvents(global::Windows.UI.Xaml.UIElement data) + public RxUIElementEvents(global::Windows.UI.Xaml.UIElement data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)> AccessKeyDisplayDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)> AccessKeyDisplayRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)> AccessKeyInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args)> BringIntoViewRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BringIntoViewRequested += x, x => _data.BringIntoViewRequested -= x); + }, x => _data.BringIntoViewRequested += x, x => _data.BringIntoViewRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args)> CharacterReceived => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args)> ContextCanceled => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContextCanceled += x, x => _data.ContextCanceled -= x); + }, x => _data.ContextCanceled += x, x => _data.ContextCanceled -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args)> ContextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContextRequested += x, x => _data.ContextRequested -= x); + }, x => _data.ContextRequested += x, x => _data.ContextRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DoubleTapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); + }, x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DragEnter => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragEnter += x, x => _data.DragEnter -= x); + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DragLeave => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragLeave += x, x => _data.DragLeave -= x); + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragOver += x, x => _data.DragOver -= x); + }, x => _data.DragOver += x, x => _data.DragOver -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args)> DragStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragStarting += x, x => _data.DragStarting -= x); + }, x => _data.DragStarting += x, x => _data.DragStarting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drop += x, x => _data.Drop -= x); + }, x => _data.Drop += x, x => _data.Drop -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args)> DropCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DropCompleted += x, x => _data.DropCompleted -= x); + }, x => _data.DropCompleted += x, x => _data.DropCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args)> GettingFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GettingFocus += x, x => _data.GettingFocus -= x); + }, x => _data.GettingFocus += x, x => _data.GettingFocus -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Holding => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.HoldingRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Holding += x, x => _data.Holding -= x); + }, x => _data.Holding += x, x => _data.Holding -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args)> LosingFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ManipulationDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ManipulationInertiaStarting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ManipulationStarting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args)> NoFocusCandidateFound => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NoFocusCandidateFound += x, x => _data.NoFocusCandidateFound -= x); + }, x => _data.NoFocusCandidateFound += x, x => _data.NoFocusCandidateFound -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerCanceled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerCanceled += x, x => _data.PointerCanceled -= x); + }, x => _data.PointerCanceled += x, x => _data.PointerCanceled -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerCaptureLost => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerEntered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerExited => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerMoved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerReleased => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PointerWheelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PreviewKeyDown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PreviewKeyUp => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args)> ProcessKeyboardAccelerators => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProcessKeyboardAccelerators += x, x => _data.ProcessKeyboardAccelerators -= x); + }, x => _data.ProcessKeyboardAccelerators += x, x => _data.ProcessKeyboardAccelerators -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable RightTapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.RightTappedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RightTapped += x, x => _data.RightTapped -= x); + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Input.TappedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class VisualStateEvents + public class RxVisualStateEvents { private readonly global::Windows.UI.Xaml.VisualState _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public VisualStateEvents(global::Windows.UI.Xaml.VisualState data) + public RxVisualStateEvents(global::Windows.UI.Xaml.VisualState data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class VisualStateGroupEvents + public class RxVisualStateGroupEvents { private readonly global::Windows.UI.Xaml.VisualStateGroup _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public VisualStateGroupEvents(global::Windows.UI.Xaml.VisualStateGroup data) + public RxVisualStateGroupEvents(global::Windows.UI.Xaml.VisualStateGroup data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable CurrentStateChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class VisualStateManagerEvents + public class RxVisualStateManagerEvents { private readonly global::Windows.UI.Xaml.VisualStateManager _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public VisualStateManagerEvents(global::Windows.UI.Xaml.VisualStateManager data) + public RxVisualStateManagerEvents(global::Windows.UI.Xaml.VisualStateManager data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class VisualTransitionEvents + public class RxVisualTransitionEvents { private readonly global::Windows.UI.Xaml.VisualTransition _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public VisualTransitionEvents(global::Windows.UI.Xaml.VisualTransition data) + public RxVisualTransitionEvents(global::Windows.UI.Xaml.VisualTransition data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class WindowEvents + public class RxWindowEvents { private readonly global::Windows.UI.Xaml.Window _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WindowEvents(global::Windows.UI.Xaml.Window data) + public RxWindowEvents(global::Windows.UI.Xaml.Window data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Core.WindowActivatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Core.WindowSizeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable VisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Core.VisibilityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } } @@ -17677,34 +15877,32 @@ namespace Windows.UI.Xaml.Automation /// /// A wrapper class which wraps all the events contained within the class. /// - public static AutomationAnnotationEvents Events(this global::Windows.UI.Xaml.Automation.AutomationAnnotation item) => new AutomationAnnotationEvents(item); + public static RxAutomationAnnotationEvents Events(this global::Windows.UI.Xaml.Automation.AutomationAnnotation item) => new RxAutomationAnnotationEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AutomationAnnotationEvents + public class RxAutomationAnnotationEvents { private readonly global::Windows.UI.Xaml.Automation.AutomationAnnotation _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AutomationAnnotationEvents(global::Windows.UI.Xaml.Automation.AutomationAnnotation data) + public RxAutomationAnnotationEvents(global::Windows.UI.Xaml.Automation.AutomationAnnotation data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -17718,65 +15916,61 @@ namespace Windows.UI.Xaml.Automation.Peers /// /// A wrapper class which wraps all the events contained within the class. /// - public static AutomationPeerEvents Events(this global::Windows.UI.Xaml.Automation.Peers.AutomationPeer item) => new AutomationPeerEvents(item); + public static RxAutomationPeerEvents Events(this global::Windows.UI.Xaml.Automation.Peers.AutomationPeer item) => new RxAutomationPeerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AutomationPeerAnnotationEvents Events(this global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation item) => new AutomationPeerAnnotationEvents(item); + public static RxAutomationPeerAnnotationEvents Events(this global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation item) => new RxAutomationPeerAnnotationEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AutomationPeerEvents + public class RxAutomationPeerEvents { private readonly global::Windows.UI.Xaml.Automation.Peers.AutomationPeer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AutomationPeerEvents(global::Windows.UI.Xaml.Automation.Peers.AutomationPeer data) + public RxAutomationPeerEvents(global::Windows.UI.Xaml.Automation.Peers.AutomationPeer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AutomationPeerAnnotationEvents + public class RxAutomationPeerAnnotationEvents { private readonly global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AutomationPeerAnnotationEvents(global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation data) + public RxAutomationPeerAnnotationEvents(global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -17790,34 +15984,32 @@ namespace Windows.UI.Xaml.Automation.Provider /// /// A wrapper class which wraps all the events contained within the class. /// - public static IRawElementProviderSimpleEvents Events(this global::Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple item) => new IRawElementProviderSimpleEvents(item); + public static RxIRawElementProviderSimpleEvents Events(this global::Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple item) => new RxIRawElementProviderSimpleEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class IRawElementProviderSimpleEvents + public class RxIRawElementProviderSimpleEvents { private readonly global::Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IRawElementProviderSimpleEvents(global::Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple data) + public RxIRawElementProviderSimpleEvents(global::Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -17831,3679 +16023,3263 @@ namespace Windows.UI.Xaml.Controls /// /// A wrapper class which wraps all the events contained within the class. /// - public static AppBarEvents Events(this global::Windows.UI.Xaml.Controls.AppBar item) => new AppBarEvents(item); + public static RxAppBarEvents Events(this global::Windows.UI.Xaml.Controls.AppBar item) => new RxAppBarEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AutoSuggestBoxEvents Events(this global::Windows.UI.Xaml.Controls.AutoSuggestBox item) => new AutoSuggestBoxEvents(item); + public static RxAutoSuggestBoxEvents Events(this global::Windows.UI.Xaml.Controls.AutoSuggestBox item) => new RxAutoSuggestBoxEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AutoSuggestBoxQuerySubmittedEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs item) => new AutoSuggestBoxQuerySubmittedEventArgsEvents(item); + public static RxAutoSuggestBoxQuerySubmittedEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs item) => new RxAutoSuggestBoxQuerySubmittedEventArgsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AutoSuggestBoxSuggestionChosenEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs item) => new AutoSuggestBoxSuggestionChosenEventArgsEvents(item); + public static RxAutoSuggestBoxSuggestionChosenEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs item) => new RxAutoSuggestBoxSuggestionChosenEventArgsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AutoSuggestBoxTextChangedEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs item) => new AutoSuggestBoxTextChangedEventArgsEvents(item); + public static RxAutoSuggestBoxTextChangedEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs item) => new RxAutoSuggestBoxTextChangedEventArgsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CalendarDatePickerEvents Events(this global::Windows.UI.Xaml.Controls.CalendarDatePicker item) => new CalendarDatePickerEvents(item); + public static RxCalendarDatePickerEvents Events(this global::Windows.UI.Xaml.Controls.CalendarDatePicker item) => new RxCalendarDatePickerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CalendarViewEvents Events(this global::Windows.UI.Xaml.Controls.CalendarView item) => new CalendarViewEvents(item); + public static RxCalendarViewEvents Events(this global::Windows.UI.Xaml.Controls.CalendarView item) => new RxCalendarViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ColorPickerEvents Events(this global::Windows.UI.Xaml.Controls.ColorPicker item) => new ColorPickerEvents(item); + public static RxColorPickerEvents Events(this global::Windows.UI.Xaml.Controls.ColorPicker item) => new RxColorPickerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ColumnDefinitionEvents Events(this global::Windows.UI.Xaml.Controls.ColumnDefinition item) => new ColumnDefinitionEvents(item); + public static RxColumnDefinitionEvents Events(this global::Windows.UI.Xaml.Controls.ColumnDefinition item) => new RxColumnDefinitionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ComboBoxEvents Events(this global::Windows.UI.Xaml.Controls.ComboBox item) => new ComboBoxEvents(item); + public static RxComboBoxEvents Events(this global::Windows.UI.Xaml.Controls.ComboBox item) => new RxComboBoxEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CommandBarEvents Events(this global::Windows.UI.Xaml.Controls.CommandBar item) => new CommandBarEvents(item); + public static RxCommandBarEvents Events(this global::Windows.UI.Xaml.Controls.CommandBar item) => new RxCommandBarEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ContentDialogEvents Events(this global::Windows.UI.Xaml.Controls.ContentDialog item) => new ContentDialogEvents(item); + public static RxContentDialogEvents Events(this global::Windows.UI.Xaml.Controls.ContentDialog item) => new RxContentDialogEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ControlEvents Events(this global::Windows.UI.Xaml.Controls.Control item) => new ControlEvents(item); + public static RxControlEvents Events(this global::Windows.UI.Xaml.Controls.Control item) => new RxControlEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DatePickedEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.DatePickedEventArgs item) => new DatePickedEventArgsEvents(item); + public static RxDatePickedEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.DatePickedEventArgs item) => new RxDatePickedEventArgsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DatePickerEvents Events(this global::Windows.UI.Xaml.Controls.DatePicker item) => new DatePickerEvents(item); + public static RxDatePickerEvents Events(this global::Windows.UI.Xaml.Controls.DatePicker item) => new RxDatePickerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DatePickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.DatePickerFlyout item) => new DatePickerFlyoutEvents(item); + public static RxDatePickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.DatePickerFlyout item) => new RxDatePickerFlyoutEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DatePickerFlyoutItemEvents Events(this global::Windows.UI.Xaml.Controls.DatePickerFlyoutItem item) => new DatePickerFlyoutItemEvents(item); + public static RxDatePickerFlyoutItemEvents Events(this global::Windows.UI.Xaml.Controls.DatePickerFlyoutItem item) => new RxDatePickerFlyoutItemEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static FrameEvents Events(this global::Windows.UI.Xaml.Controls.Frame item) => new FrameEvents(item); + public static RxFrameEvents Events(this global::Windows.UI.Xaml.Controls.Frame item) => new RxFrameEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GroupStyleEvents Events(this global::Windows.UI.Xaml.Controls.GroupStyle item) => new GroupStyleEvents(item); + public static RxGroupStyleEvents Events(this global::Windows.UI.Xaml.Controls.GroupStyle item) => new RxGroupStyleEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static HandwritingViewEvents Events(this global::Windows.UI.Xaml.Controls.HandwritingView item) => new HandwritingViewEvents(item); + public static RxHandwritingViewEvents Events(this global::Windows.UI.Xaml.Controls.HandwritingView item) => new RxHandwritingViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static HubEvents Events(this global::Windows.UI.Xaml.Controls.Hub item) => new HubEvents(item); + public static RxHubEvents Events(this global::Windows.UI.Xaml.Controls.Hub item) => new RxHubEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IconSourceEvents Events(this global::Windows.UI.Xaml.Controls.IconSource item) => new IconSourceEvents(item); + public static RxIconSourceEvents Events(this global::Windows.UI.Xaml.Controls.IconSource item) => new RxIconSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ImageEvents Events(this global::Windows.UI.Xaml.Controls.Image item) => new ImageEvents(item); + public static RxImageEvents Events(this global::Windows.UI.Xaml.Controls.Image item) => new RxImageEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static InkToolbarEvents Events(this global::Windows.UI.Xaml.Controls.InkToolbar item) => new InkToolbarEvents(item); + public static RxInkToolbarEvents Events(this global::Windows.UI.Xaml.Controls.InkToolbar item) => new RxInkToolbarEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static InkToolbarCustomPenEvents Events(this global::Windows.UI.Xaml.Controls.InkToolbarCustomPen item) => new InkToolbarCustomPenEvents(item); + public static RxInkToolbarCustomPenEvents Events(this global::Windows.UI.Xaml.Controls.InkToolbarCustomPen item) => new RxInkToolbarCustomPenEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static InkToolbarFlyoutItemEvents Events(this global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem item) => new InkToolbarFlyoutItemEvents(item); + public static RxInkToolbarFlyoutItemEvents Events(this global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem item) => new RxInkToolbarFlyoutItemEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IPopupEvents Events(this global::Windows.UI.Xaml.Controls.IPopup item) => new IPopupEvents(item); + public static RxIPopupEvents Events(this global::Windows.UI.Xaml.Controls.IPopup item) => new RxIPopupEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ISelectorEvents Events(this global::Windows.UI.Xaml.Controls.ISelector item) => new ISelectorEvents(item); + public static RxISelectorEvents Events(this global::Windows.UI.Xaml.Controls.ISelector item) => new RxISelectorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ItemCollectionEvents Events(this global::Windows.UI.Xaml.Controls.ItemCollection item) => new ItemCollectionEvents(item); + public static RxItemCollectionEvents Events(this global::Windows.UI.Xaml.Controls.ItemCollection item) => new RxItemCollectionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ItemContainerGeneratorEvents Events(this global::Windows.UI.Xaml.Controls.ItemContainerGenerator item) => new ItemContainerGeneratorEvents(item); + public static RxItemContainerGeneratorEvents Events(this global::Windows.UI.Xaml.Controls.ItemContainerGenerator item) => new RxItemContainerGeneratorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ItemsPickedEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs item) => new ItemsPickedEventArgsEvents(item); + public static RxItemsPickedEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs item) => new RxItemsPickedEventArgsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ItemsPresenterEvents Events(this global::Windows.UI.Xaml.Controls.ItemsPresenter item) => new ItemsPresenterEvents(item); + public static RxItemsPresenterEvents Events(this global::Windows.UI.Xaml.Controls.ItemsPresenter item) => new RxItemsPresenterEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ListPickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.ListPickerFlyout item) => new ListPickerFlyoutEvents(item); + public static RxListPickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.ListPickerFlyout item) => new RxListPickerFlyoutEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ListViewBaseEvents Events(this global::Windows.UI.Xaml.Controls.ListViewBase item) => new ListViewBaseEvents(item); + public static RxListViewBaseEvents Events(this global::Windows.UI.Xaml.Controls.ListViewBase item) => new RxListViewBaseEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaElementEvents Events(this global::Windows.UI.Xaml.Controls.MediaElement item) => new MediaElementEvents(item); + public static RxMediaElementEvents Events(this global::Windows.UI.Xaml.Controls.MediaElement item) => new RxMediaElementEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MediaTransportControlsEvents Events(this global::Windows.UI.Xaml.Controls.MediaTransportControls item) => new MediaTransportControlsEvents(item); + public static RxMediaTransportControlsEvents Events(this global::Windows.UI.Xaml.Controls.MediaTransportControls item) => new RxMediaTransportControlsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MenuFlyoutItemEvents Events(this global::Windows.UI.Xaml.Controls.MenuFlyoutItem item) => new MenuFlyoutItemEvents(item); + public static RxMenuFlyoutItemEvents Events(this global::Windows.UI.Xaml.Controls.MenuFlyoutItem item) => new RxMenuFlyoutItemEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static NavigationViewEvents Events(this global::Windows.UI.Xaml.Controls.NavigationView item) => new NavigationViewEvents(item); + public static RxNavigationViewEvents Events(this global::Windows.UI.Xaml.Controls.NavigationView item) => new RxNavigationViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static NavigationViewTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.NavigationViewTemplateSettings item) => new NavigationViewTemplateSettingsEvents(item); + public static RxNavigationViewTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.NavigationViewTemplateSettings item) => new RxNavigationViewTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PasswordBoxEvents Events(this global::Windows.UI.Xaml.Controls.PasswordBox item) => new PasswordBoxEvents(item); + public static RxPasswordBoxEvents Events(this global::Windows.UI.Xaml.Controls.PasswordBox item) => new RxPasswordBoxEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PickerConfirmedEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs item) => new PickerConfirmedEventArgsEvents(item); + public static RxPickerConfirmedEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs item) => new RxPickerConfirmedEventArgsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.PickerFlyout item) => new PickerFlyoutEvents(item); + public static RxPickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.PickerFlyout item) => new RxPickerFlyoutEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PivotEvents Events(this global::Windows.UI.Xaml.Controls.Pivot item) => new PivotEvents(item); + public static RxPivotEvents Events(this global::Windows.UI.Xaml.Controls.Pivot item) => new RxPivotEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PopupBaseEvents Events(this global::Windows.UI.Xaml.Controls.PopupBase item) => new PopupBaseEvents(item); + public static RxPopupBaseEvents Events(this global::Windows.UI.Xaml.Controls.PopupBase item) => new RxPopupBaseEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RatingControlEvents Events(this global::Windows.UI.Xaml.Controls.RatingControl item) => new RatingControlEvents(item); + public static RxRatingControlEvents Events(this global::Windows.UI.Xaml.Controls.RatingControl item) => new RxRatingControlEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RatingItemInfoEvents Events(this global::Windows.UI.Xaml.Controls.RatingItemInfo item) => new RatingItemInfoEvents(item); + public static RxRatingItemInfoEvents Events(this global::Windows.UI.Xaml.Controls.RatingItemInfo item) => new RxRatingItemInfoEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RefreshContainerEvents Events(this global::Windows.UI.Xaml.Controls.RefreshContainer item) => new RefreshContainerEvents(item); + public static RxRefreshContainerEvents Events(this global::Windows.UI.Xaml.Controls.RefreshContainer item) => new RxRefreshContainerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RefreshVisualizerEvents Events(this global::Windows.UI.Xaml.Controls.RefreshVisualizer item) => new RefreshVisualizerEvents(item); + public static RxRefreshVisualizerEvents Events(this global::Windows.UI.Xaml.Controls.RefreshVisualizer item) => new RxRefreshVisualizerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RichEditBoxEvents Events(this global::Windows.UI.Xaml.Controls.RichEditBox item) => new RichEditBoxEvents(item); + public static RxRichEditBoxEvents Events(this global::Windows.UI.Xaml.Controls.RichEditBox item) => new RxRichEditBoxEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RichTextBlockEvents Events(this global::Windows.UI.Xaml.Controls.RichTextBlock item) => new RichTextBlockEvents(item); + public static RxRichTextBlockEvents Events(this global::Windows.UI.Xaml.Controls.RichTextBlock item) => new RxRichTextBlockEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RichTextBlockOverflowEvents Events(this global::Windows.UI.Xaml.Controls.RichTextBlockOverflow item) => new RichTextBlockOverflowEvents(item); + public static RxRichTextBlockOverflowEvents Events(this global::Windows.UI.Xaml.Controls.RichTextBlockOverflow item) => new RxRichTextBlockOverflowEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RowDefinitionEvents Events(this global::Windows.UI.Xaml.Controls.RowDefinition item) => new RowDefinitionEvents(item); + public static RxRowDefinitionEvents Events(this global::Windows.UI.Xaml.Controls.RowDefinition item) => new RxRowDefinitionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ScrollViewerEvents Events(this global::Windows.UI.Xaml.Controls.ScrollViewer item) => new ScrollViewerEvents(item); + public static RxScrollViewerEvents Events(this global::Windows.UI.Xaml.Controls.ScrollViewer item) => new RxScrollViewerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SearchBoxEvents Events(this global::Windows.UI.Xaml.Controls.SearchBox item) => new SearchBoxEvents(item); + public static RxSearchBoxEvents Events(this global::Windows.UI.Xaml.Controls.SearchBox item) => new RxSearchBoxEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SemanticZoomEvents Events(this global::Windows.UI.Xaml.Controls.SemanticZoom item) => new SemanticZoomEvents(item); + public static RxSemanticZoomEvents Events(this global::Windows.UI.Xaml.Controls.SemanticZoom item) => new RxSemanticZoomEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SettingsFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.SettingsFlyout item) => new SettingsFlyoutEvents(item); + public static RxSettingsFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.SettingsFlyout item) => new RxSettingsFlyoutEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SplitButtonEvents Events(this global::Windows.UI.Xaml.Controls.SplitButton item) => new SplitButtonEvents(item); + public static RxSplitButtonEvents Events(this global::Windows.UI.Xaml.Controls.SplitButton item) => new RxSplitButtonEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SplitViewEvents Events(this global::Windows.UI.Xaml.Controls.SplitView item) => new SplitViewEvents(item); + public static RxSplitViewEvents Events(this global::Windows.UI.Xaml.Controls.SplitView item) => new RxSplitViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static StackPanelEvents Events(this global::Windows.UI.Xaml.Controls.StackPanel item) => new StackPanelEvents(item); + public static RxStackPanelEvents Events(this global::Windows.UI.Xaml.Controls.StackPanel item) => new RxStackPanelEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SwapChainPanelEvents Events(this global::Windows.UI.Xaml.Controls.SwapChainPanel item) => new SwapChainPanelEvents(item); + public static RxSwapChainPanelEvents Events(this global::Windows.UI.Xaml.Controls.SwapChainPanel item) => new RxSwapChainPanelEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SwipeItemEvents Events(this global::Windows.UI.Xaml.Controls.SwipeItem item) => new SwipeItemEvents(item); + public static RxSwipeItemEvents Events(this global::Windows.UI.Xaml.Controls.SwipeItem item) => new RxSwipeItemEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SwipeItemsEvents Events(this global::Windows.UI.Xaml.Controls.SwipeItems item) => new SwipeItemsEvents(item); + public static RxSwipeItemsEvents Events(this global::Windows.UI.Xaml.Controls.SwipeItems item) => new RxSwipeItemsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TextBlockEvents Events(this global::Windows.UI.Xaml.Controls.TextBlock item) => new TextBlockEvents(item); + public static RxTextBlockEvents Events(this global::Windows.UI.Xaml.Controls.TextBlock item) => new RxTextBlockEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TextBoxEvents Events(this global::Windows.UI.Xaml.Controls.TextBox item) => new TextBoxEvents(item); + public static RxTextBoxEvents Events(this global::Windows.UI.Xaml.Controls.TextBox item) => new RxTextBoxEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TimePickedEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.TimePickedEventArgs item) => new TimePickedEventArgsEvents(item); + public static RxTimePickedEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.TimePickedEventArgs item) => new RxTimePickedEventArgsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TimePickerEvents Events(this global::Windows.UI.Xaml.Controls.TimePicker item) => new TimePickerEvents(item); + public static RxTimePickerEvents Events(this global::Windows.UI.Xaml.Controls.TimePicker item) => new RxTimePickerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TimePickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.TimePickerFlyout item) => new TimePickerFlyoutEvents(item); + public static RxTimePickerFlyoutEvents Events(this global::Windows.UI.Xaml.Controls.TimePickerFlyout item) => new RxTimePickerFlyoutEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ToggleSplitButtonEvents Events(this global::Windows.UI.Xaml.Controls.ToggleSplitButton item) => new ToggleSplitButtonEvents(item); + public static RxToggleSplitButtonEvents Events(this global::Windows.UI.Xaml.Controls.ToggleSplitButton item) => new RxToggleSplitButtonEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ToggleSwitchEvents Events(this global::Windows.UI.Xaml.Controls.ToggleSwitch item) => new ToggleSwitchEvents(item); + public static RxToggleSwitchEvents Events(this global::Windows.UI.Xaml.Controls.ToggleSwitch item) => new RxToggleSwitchEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ToolTipEvents Events(this global::Windows.UI.Xaml.Controls.ToolTip item) => new ToolTipEvents(item); + public static RxToolTipEvents Events(this global::Windows.UI.Xaml.Controls.ToolTip item) => new RxToolTipEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TreeViewEvents Events(this global::Windows.UI.Xaml.Controls.TreeView item) => new TreeViewEvents(item); + public static RxTreeViewEvents Events(this global::Windows.UI.Xaml.Controls.TreeView item) => new RxTreeViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TreeViewItemTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.TreeViewItemTemplateSettings item) => new TreeViewItemTemplateSettingsEvents(item); + public static RxTreeViewItemTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.TreeViewItemTemplateSettings item) => new RxTreeViewItemTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TreeViewNodeEvents Events(this global::Windows.UI.Xaml.Controls.TreeViewNode item) => new TreeViewNodeEvents(item); + public static RxTreeViewNodeEvents Events(this global::Windows.UI.Xaml.Controls.TreeViewNode item) => new RxTreeViewNodeEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static VirtualizingPanelLayoutEvents Events(this global::Windows.UI.Xaml.Controls.VirtualizingPanelLayout item) => new VirtualizingPanelLayoutEvents(item); + public static RxVirtualizingPanelLayoutEvents Events(this global::Windows.UI.Xaml.Controls.VirtualizingPanelLayout item) => new RxVirtualizingPanelLayoutEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static VirtualizingStackPanelEvents Events(this global::Windows.UI.Xaml.Controls.VirtualizingStackPanel item) => new VirtualizingStackPanelEvents(item); + public static RxVirtualizingStackPanelEvents Events(this global::Windows.UI.Xaml.Controls.VirtualizingStackPanel item) => new RxVirtualizingStackPanelEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static WebViewEvents Events(this global::Windows.UI.Xaml.Controls.WebView item) => new WebViewEvents(item); + public static RxWebViewEvents Events(this global::Windows.UI.Xaml.Controls.WebView item) => new RxWebViewEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AppBarEvents + public class RxAppBarEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.AppBar _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AppBarEvents(global::Windows.UI.Xaml.Controls.AppBar data) + public RxAppBarEvents(global::Windows.UI.Xaml.Controls.AppBar data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Closing => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opening += x, x => _data.Opening -= x); + }, x => _data.Opening += x, x => _data.Opening -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AutoSuggestBoxEvents + public class RxAutoSuggestBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.AutoSuggestBox _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AutoSuggestBoxEvents(global::Windows.UI.Xaml.Controls.AutoSuggestBox data) + public RxAutoSuggestBoxEvents(global::Windows.UI.Xaml.Controls.AutoSuggestBox data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args)> QuerySubmitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args)> SuggestionChosen => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SuggestionChosen += x, x => _data.SuggestionChosen -= x); + }, x => _data.SuggestionChosen += x, x => _data.SuggestionChosen -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args)> TextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AutoSuggestBoxQuerySubmittedEventArgsEvents + public class RxAutoSuggestBoxQuerySubmittedEventArgsEvents { private readonly global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AutoSuggestBoxQuerySubmittedEventArgsEvents(global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs data) + public RxAutoSuggestBoxQuerySubmittedEventArgsEvents(global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AutoSuggestBoxSuggestionChosenEventArgsEvents + public class RxAutoSuggestBoxSuggestionChosenEventArgsEvents { private readonly global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AutoSuggestBoxSuggestionChosenEventArgsEvents(global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs data) + public RxAutoSuggestBoxSuggestionChosenEventArgsEvents(global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AutoSuggestBoxTextChangedEventArgsEvents + public class RxAutoSuggestBoxTextChangedEventArgsEvents { private readonly global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AutoSuggestBoxTextChangedEventArgsEvents(global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs data) + public RxAutoSuggestBoxTextChangedEventArgsEvents(global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CalendarDatePickerEvents + public class RxCalendarDatePickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.CalendarDatePicker _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CalendarDatePickerEvents(global::Windows.UI.Xaml.Controls.CalendarDatePicker data) + public RxCalendarDatePickerEvents(global::Windows.UI.Xaml.Controls.CalendarDatePicker data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs e)> CalendarViewDayItemChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs e) => eventHandler((sender, e)); return Handler; - } - - , x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args)> DateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DateChanged += x, x => _data.DateChanged -= x); + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CalendarViewEvents + public class RxCalendarViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.CalendarView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CalendarViewEvents(global::Windows.UI.Xaml.Controls.CalendarView data) + public RxCalendarViewEvents(global::Windows.UI.Xaml.Controls.CalendarView data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args)> CalendarViewDayItemChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args)> SelectedDatesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ColorPickerEvents + public class RxColorPickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.ColorPicker _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ColorPickerEvents(global::Windows.UI.Xaml.Controls.ColorPicker data) + public RxColorPickerEvents(global::Windows.UI.Xaml.Controls.ColorPicker data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)> ColorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ColumnDefinitionEvents + public class RxColumnDefinitionEvents { private readonly global::Windows.UI.Xaml.Controls.ColumnDefinition _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Windows.UI.Xaml.Controls.ColumnDefinition data) + public RxColumnDefinitionEvents(global::Windows.UI.Xaml.Controls.ColumnDefinition data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ComboBoxEvents + public class RxComboBoxEvents : global::Windows.UI.Xaml.Controls.RxListViewBaseEvents { private readonly global::Windows.UI.Xaml.Controls.ComboBox _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ComboBoxEvents(global::Windows.UI.Xaml.Controls.ComboBox data) + public RxComboBoxEvents(global::Windows.UI.Xaml.Controls.ComboBox data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DropDownClosed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DropDownOpened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args)> TextSubmitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextSubmitted += x, x => _data.TextSubmitted -= x); + }, x => _data.TextSubmitted += x, x => _data.TextSubmitted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CommandBarEvents + public class RxCommandBarEvents : global::Windows.UI.Xaml.Controls.RxAppBarEvents { private readonly global::Windows.UI.Xaml.Controls.CommandBar _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CommandBarEvents(global::Windows.UI.Xaml.Controls.CommandBar data) + public RxCommandBarEvents(global::Windows.UI.Xaml.Controls.CommandBar data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args)> DynamicOverflowItemsChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DynamicOverflowItemsChanging += x, x => _data.DynamicOverflowItemsChanging -= x); + }, x => _data.DynamicOverflowItemsChanging += x, x => _data.DynamicOverflowItemsChanging -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ContentDialogEvents + public class RxContentDialogEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.ContentDialog _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ContentDialogEvents(global::Windows.UI.Xaml.Controls.ContentDialog data) + public RxContentDialogEvents(global::Windows.UI.Xaml.Controls.ContentDialog data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)> CloseButtonClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CloseButtonClick += x, x => _data.CloseButtonClick -= x); + }, x => _data.CloseButtonClick += x, x => _data.CloseButtonClick -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)> PrimaryButtonClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrimaryButtonClick += x, x => _data.PrimaryButtonClick -= x); + }, x => _data.PrimaryButtonClick += x, x => _data.PrimaryButtonClick -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)> SecondaryButtonClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SecondaryButtonClick += x, x => _data.SecondaryButtonClick -= x); + }, x => _data.SecondaryButtonClick += x, x => _data.SecondaryButtonClick -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ControlEvents + public class RxControlEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents { private readonly global::Windows.UI.Xaml.Controls.Control _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ControlEvents(global::Windows.UI.Xaml.Controls.Control data) + public RxControlEvents(global::Windows.UI.Xaml.Controls.Control data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args)> FocusDisengaged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusDisengaged += x, x => _data.FocusDisengaged -= x); + }, x => _data.FocusDisengaged += x, x => _data.FocusDisengaged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args)> FocusEngaged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusEngaged += x, x => _data.FocusEngaged -= x); + }, x => _data.FocusEngaged += x, x => _data.FocusEngaged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DatePickedEventArgsEvents + public class RxDatePickedEventArgsEvents { private readonly global::Windows.UI.Xaml.Controls.DatePickedEventArgs _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DatePickedEventArgsEvents(global::Windows.UI.Xaml.Controls.DatePickedEventArgs data) + public RxDatePickedEventArgsEvents(global::Windows.UI.Xaml.Controls.DatePickedEventArgs data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DatePickerEvents + public class RxDatePickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.DatePicker _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DatePickerEvents(global::Windows.UI.Xaml.Controls.DatePicker data) + public RxDatePickerEvents(global::Windows.UI.Xaml.Controls.DatePicker data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateChanged += x, x => _data.DateChanged -= x); + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args)> SelectedDateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DatePickerFlyoutEvents + public class RxDatePickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents { private readonly global::Windows.UI.Xaml.Controls.DatePickerFlyout _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DatePickerFlyoutEvents(global::Windows.UI.Xaml.Controls.DatePickerFlyout data) + public RxDatePickerFlyoutEvents(global::Windows.UI.Xaml.Controls.DatePickerFlyout data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args)> DatePicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DatePicked += x, x => _data.DatePicked -= x); + }, x => _data.DatePicked += x, x => _data.DatePicked -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DatePickerFlyoutItemEvents + public class RxDatePickerFlyoutItemEvents { private readonly global::Windows.UI.Xaml.Controls.DatePickerFlyoutItem _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DatePickerFlyoutItemEvents(global::Windows.UI.Xaml.Controls.DatePickerFlyoutItem data) + public RxDatePickerFlyoutItemEvents(global::Windows.UI.Xaml.Controls.DatePickerFlyoutItem data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class FrameEvents + public class RxFrameEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.Frame _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public FrameEvents(global::Windows.UI.Xaml.Controls.Frame data) + public RxFrameEvents(global::Windows.UI.Xaml.Controls.Frame data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationFailedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable NavigationStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GroupStyleEvents + public class RxGroupStyleEvents { private readonly global::Windows.UI.Xaml.Controls.GroupStyle _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GroupStyleEvents(global::Windows.UI.Xaml.Controls.GroupStyle data) + public RxGroupStyleEvents(global::Windows.UI.Xaml.Controls.GroupStyle data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class HandwritingViewEvents + public class RxHandwritingViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.HandwritingView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public HandwritingViewEvents(global::Windows.UI.Xaml.Controls.HandwritingView data) + public RxHandwritingViewEvents(global::Windows.UI.Xaml.Controls.HandwritingView data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args)> Closed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class HubEvents + public class RxHubEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.Hub _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public HubEvents(global::Windows.UI.Xaml.Controls.Hub data) + public RxHubEvents(global::Windows.UI.Xaml.Controls.Hub data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable SectionHeaderClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.HubSectionHeaderClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SectionHeaderClick += x, x => _data.SectionHeaderClick -= x); + }, x => _data.SectionHeaderClick += x, x => _data.SectionHeaderClick -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable SectionsInViewChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.SectionsInViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SectionsInViewChanged += x, x => _data.SectionsInViewChanged -= x); + }, x => _data.SectionsInViewChanged += x, x => _data.SectionsInViewChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IconSourceEvents + public class RxIconSourceEvents { private readonly global::Windows.UI.Xaml.Controls.IconSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IconSourceEvents(global::Windows.UI.Xaml.Controls.IconSource data) + public RxIconSourceEvents(global::Windows.UI.Xaml.Controls.IconSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ImageEvents + public class RxImageEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents { private readonly global::Windows.UI.Xaml.Controls.Image _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ImageEvents(global::Windows.UI.Xaml.Controls.Image data) + public RxImageEvents(global::Windows.UI.Xaml.Controls.Image data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ImageOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class InkToolbarEvents + public class RxInkToolbarEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.InkToolbar _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public InkToolbarEvents(global::Windows.UI.Xaml.Controls.InkToolbar data) + public RxInkToolbarEvents(global::Windows.UI.Xaml.Controls.InkToolbar data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> ActiveToolChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveToolChanged += x, x => _data.ActiveToolChanged -= x); + }, x => _data.ActiveToolChanged += x, x => _data.ActiveToolChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> EraseAllClicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EraseAllClicked += x, x => _data.EraseAllClicked -= x); + }, x => _data.EraseAllClicked += x, x => _data.EraseAllClicked -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> InkDrawingAttributesChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InkDrawingAttributesChanged += x, x => _data.InkDrawingAttributesChanged -= x); + }, x => _data.InkDrawingAttributesChanged += x, x => _data.InkDrawingAttributesChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)> IsRulerButtonCheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsRulerButtonCheckedChanged += x, x => _data.IsRulerButtonCheckedChanged -= x); + }, x => _data.IsRulerButtonCheckedChanged += x, x => _data.IsRulerButtonCheckedChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args)> IsStencilButtonCheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsStencilButtonCheckedChanged += x, x => _data.IsStencilButtonCheckedChanged -= x); + }, x => _data.IsStencilButtonCheckedChanged += x, x => _data.IsStencilButtonCheckedChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class InkToolbarCustomPenEvents + public class RxInkToolbarCustomPenEvents { private readonly global::Windows.UI.Xaml.Controls.InkToolbarCustomPen _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public InkToolbarCustomPenEvents(global::Windows.UI.Xaml.Controls.InkToolbarCustomPen data) + public RxInkToolbarCustomPenEvents(global::Windows.UI.Xaml.Controls.InkToolbarCustomPen data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class InkToolbarFlyoutItemEvents + public class RxInkToolbarFlyoutItemEvents : global::Windows.UI.Xaml.Controls.Primitives.RxButtonBaseEvents { private readonly global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public InkToolbarFlyoutItemEvents(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem data) + public RxInkToolbarFlyoutItemEvents(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)> Checked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Checked += x, x => _data.Checked -= x); + }, x => _data.Checked += x, x => _data.Checked -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)> Unchecked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Unchecked += x, x => _data.Unchecked -= x); + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IPopupEvents + public class RxIPopupEvents { private readonly global::Windows.UI.Xaml.Controls.IPopup _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IPopupEvents(global::Windows.UI.Xaml.Controls.IPopup data) + public RxIPopupEvents(global::Windows.UI.Xaml.Controls.IPopup data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ISelectorEvents + public class RxISelectorEvents { private readonly global::Windows.UI.Xaml.Controls.ISelector _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ISelectorEvents(global::Windows.UI.Xaml.Controls.ISelector data) + public RxISelectorEvents(global::Windows.UI.Xaml.Controls.ISelector data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ItemCollectionEvents + public class RxItemCollectionEvents { private readonly global::Windows.UI.Xaml.Controls.ItemCollection _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ItemCollectionEvents(global::Windows.UI.Xaml.Controls.ItemCollection data) + public RxItemCollectionEvents(global::Windows.UI.Xaml.Controls.ItemCollection data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event)> VectorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event)>(eventHandler => { void Handler(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ItemContainerGeneratorEvents + public class RxItemContainerGeneratorEvents { private readonly global::Windows.UI.Xaml.Controls.ItemContainerGenerator _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ItemContainerGeneratorEvents(global::Windows.UI.Xaml.Controls.ItemContainerGenerator data) + public RxItemContainerGeneratorEvents(global::Windows.UI.Xaml.Controls.ItemContainerGenerator data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ItemsChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ItemsPickedEventArgsEvents + public class RxItemsPickedEventArgsEvents { private readonly global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ItemsPickedEventArgsEvents(global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs data) + public RxItemsPickedEventArgsEvents(global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ItemsPresenterEvents + public class RxItemsPresenterEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents { private readonly global::Windows.UI.Xaml.Controls.ItemsPresenter _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ItemsPresenterEvents(global::Windows.UI.Xaml.Controls.ItemsPresenter data) + public RxItemsPresenterEvents(global::Windows.UI.Xaml.Controls.ItemsPresenter data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ListPickerFlyoutEvents + public class RxListPickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents { private readonly global::Windows.UI.Xaml.Controls.ListPickerFlyout _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ListPickerFlyoutEvents(global::Windows.UI.Xaml.Controls.ListPickerFlyout data) + public RxListPickerFlyoutEvents(global::Windows.UI.Xaml.Controls.ListPickerFlyout data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args)> ItemsPicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemsPicked += x, x => _data.ItemsPicked -= x); + }, x => _data.ItemsPicked += x, x => _data.ItemsPicked -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ListViewBaseEvents + public class RxListViewBaseEvents : global::Windows.UI.Xaml.Controls.Primitives.RxSelectorEvents { private readonly global::Windows.UI.Xaml.Controls.ListViewBase _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ListViewBaseEvents(global::Windows.UI.Xaml.Controls.ListViewBase data) + public RxListViewBaseEvents(global::Windows.UI.Xaml.Controls.ListViewBase data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args)> ChoosingGroupHeaderContainer => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ChoosingGroupHeaderContainer += x, x => _data.ChoosingGroupHeaderContainer -= x); + }, x => _data.ChoosingGroupHeaderContainer += x, x => _data.ChoosingGroupHeaderContainer -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args)> ChoosingItemContainer => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ChoosingItemContainer += x, x => _data.ChoosingItemContainer -= x); + }, x => _data.ChoosingItemContainer += x, x => _data.ChoosingItemContainer -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args)> ContainerContentChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainerContentChanging += x, x => _data.ContainerContentChanging -= x); + }, x => _data.ContainerContentChanging += x, x => _data.ContainerContentChanging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args)> DragItemsCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DragItemsStarting => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.DragItemsStartingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ItemClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.ItemClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemClick += x, x => _data.ItemClick -= x); + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaElementEvents + public class RxMediaElementEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents { private readonly global::Windows.UI.Xaml.Controls.MediaElement _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaElementEvents(global::Windows.UI.Xaml.Controls.MediaElement data) + public RxMediaElementEvents(global::Windows.UI.Xaml.Controls.MediaElement data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable BufferingProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable CurrentStateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DownloadProgressChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable MarkerReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Media.TimelineMarkerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MarkerReached += x, x => _data.MarkerReached -= x); + }, x => _data.MarkerReached += x, x => _data.MarkerReached -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args)> PartialMediaFailureDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PartialMediaFailureDetected += x, x => _data.PartialMediaFailureDetected -= x); + }, x => _data.PartialMediaFailureDetected += x, x => _data.PartialMediaFailureDetected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable RateChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Media.RateChangedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RateChanged += x, x => _data.RateChanged -= x); + }, x => _data.RateChanged += x, x => _data.RateChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable SeekCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable VolumeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MediaTransportControlsEvents + public class RxMediaTransportControlsEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.MediaTransportControls _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MediaTransportControlsEvents(global::Windows.UI.Xaml.Controls.MediaTransportControls data) + public RxMediaTransportControlsEvents(global::Windows.UI.Xaml.Controls.MediaTransportControls data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args)> ThumbnailRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailRequested += x, x => _data.ThumbnailRequested -= x); + }, x => _data.ThumbnailRequested += x, x => _data.ThumbnailRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MenuFlyoutItemEvents + public class RxMenuFlyoutItemEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.MenuFlyoutItem _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MenuFlyoutItemEvents(global::Windows.UI.Xaml.Controls.MenuFlyoutItem data) + public RxMenuFlyoutItemEvents(global::Windows.UI.Xaml.Controls.MenuFlyoutItem data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class NavigationViewEvents + public class RxNavigationViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.NavigationView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public NavigationViewEvents(global::Windows.UI.Xaml.Controls.NavigationView data) + public RxNavigationViewEvents(global::Windows.UI.Xaml.Controls.NavigationView data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args)> BackRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BackRequested += x, x => _data.BackRequested -= x); + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args)> DisplayModeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args)> ItemInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, object args)> PaneClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args)> PaneClosing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, object args)> PaneOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, object args)> PaneOpening => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args)> SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class NavigationViewTemplateSettingsEvents + public class RxNavigationViewTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.NavigationViewTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public NavigationViewTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.NavigationViewTemplateSettings data) + public RxNavigationViewTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.NavigationViewTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PasswordBoxEvents + public class RxPasswordBoxEvents : global::Windows.UI.Xaml.Controls.RxTextBoxEvents { private readonly global::Windows.UI.Xaml.Controls.PasswordBox _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PasswordBoxEvents(global::Windows.UI.Xaml.Controls.PasswordBox data) + public RxPasswordBoxEvents(global::Windows.UI.Xaml.Controls.PasswordBox data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable PasswordChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args)> PasswordChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PasswordChanging += x, x => _data.PasswordChanging -= x); + }, x => _data.PasswordChanging += x, x => _data.PasswordChanging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Paste => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paste += x, x => _data.Paste -= x); + }, x => _data.Paste += x, x => _data.Paste -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PickerConfirmedEventArgsEvents + public class RxPickerConfirmedEventArgsEvents { private readonly global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PickerConfirmedEventArgsEvents(global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs data) + public RxPickerConfirmedEventArgsEvents(global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PickerFlyoutEvents + public class RxPickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents { private readonly global::Windows.UI.Xaml.Controls.PickerFlyout _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PickerFlyoutEvents(global::Windows.UI.Xaml.Controls.PickerFlyout data) + public RxPickerFlyoutEvents(global::Windows.UI.Xaml.Controls.PickerFlyout data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args)> Confirmed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Confirmed += x, x => _data.Confirmed -= x); + }, x => _data.Confirmed += x, x => _data.Confirmed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PivotEvents + public class RxPivotEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.Pivot _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PivotEvents(global::Windows.UI.Xaml.Controls.Pivot data) + public RxPivotEvents(global::Windows.UI.Xaml.Controls.Pivot data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemLoaded += x, x => _data.PivotItemLoaded -= x); + }, x => _data.PivotItemLoaded += x, x => _data.PivotItemLoaded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemLoading += x, x => _data.PivotItemLoading -= x); + }, x => _data.PivotItemLoading += x, x => _data.PivotItemLoading -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemUnloaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemUnloaded += x, x => _data.PivotItemUnloaded -= x); + }, x => _data.PivotItemUnloaded += x, x => _data.PivotItemUnloaded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)> PivotItemUnloading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemUnloading += x, x => _data.PivotItemUnloading -= x); + }, x => _data.PivotItemUnloading += x, x => _data.PivotItemUnloading -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PopupBaseEvents + public class RxPopupBaseEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents { private readonly global::Windows.UI.Xaml.Controls.PopupBase _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PopupBaseEvents(global::Windows.UI.Xaml.Controls.PopupBase data) + public RxPopupBaseEvents(global::Windows.UI.Xaml.Controls.PopupBase data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RatingControlEvents + public class RxRatingControlEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.RatingControl _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RatingControlEvents(global::Windows.UI.Xaml.Controls.RatingControl data) + public RxRatingControlEvents(global::Windows.UI.Xaml.Controls.RatingControl data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RatingControl sender, object args)> ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RatingControl sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RatingControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RatingItemInfoEvents + public class RxRatingItemInfoEvents { private readonly global::Windows.UI.Xaml.Controls.RatingItemInfo _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RatingItemInfoEvents(global::Windows.UI.Xaml.Controls.RatingItemInfo data) + public RxRatingItemInfoEvents(global::Windows.UI.Xaml.Controls.RatingItemInfo data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RefreshContainerEvents + public class RxRefreshContainerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.RefreshContainer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RefreshContainerEvents(global::Windows.UI.Xaml.Controls.RefreshContainer data) + public RxRefreshContainerEvents(global::Windows.UI.Xaml.Controls.RefreshContainer data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)> RefreshRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RefreshVisualizerEvents + public class RxRefreshVisualizerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.RefreshVisualizer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RefreshVisualizerEvents(global::Windows.UI.Xaml.Controls.RefreshVisualizer data) + public RxRefreshVisualizerEvents(global::Windows.UI.Xaml.Controls.RefreshVisualizer data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)> RefreshRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args)> RefreshStateChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RefreshStateChanged += x, x => _data.RefreshStateChanged -= x); + }, x => _data.RefreshStateChanged += x, x => _data.RefreshStateChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RichEditBoxEvents + public class RxRichEditBoxEvents { private readonly global::Windows.UI.Xaml.Controls.RichEditBox _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RichEditBoxEvents(global::Windows.UI.Xaml.Controls.RichEditBox data) + public RxRichEditBoxEvents(global::Windows.UI.Xaml.Controls.RichEditBox data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)> CandidateWindowBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args)> ContentLinkChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLinkChanged += x, x => _data.ContentLinkChanged -= x); + }, x => _data.ContentLinkChanged += x, x => _data.ContentLinkChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)> ContentLinkInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLinkInvoked += x, x => _data.ContentLinkInvoked -= x); + }, x => _data.ContentLinkInvoked += x, x => _data.ContentLinkInvoked -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)> CopyingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)> CuttingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Paste => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paste += x, x => _data.Paste -= x); + }, x => _data.Paste += x, x => _data.Paste -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args)> SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args)> TextChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextChanging += x, x => _data.TextChanging -= x); + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)> TextCompositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)> TextCompositionEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)> TextCompositionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RichTextBlockEvents + public class RxRichTextBlockEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents { private readonly global::Windows.UI.Xaml.Controls.RichTextBlock _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RichTextBlockEvents(global::Windows.UI.Xaml.Controls.RichTextBlock data) + public RxRichTextBlockEvents(global::Windows.UI.Xaml.Controls.RichTextBlock data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)> IsTextTrimmedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RichTextBlockOverflowEvents + public class RxRichTextBlockOverflowEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents { private readonly global::Windows.UI.Xaml.Controls.RichTextBlockOverflow _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RichTextBlockOverflowEvents(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow data) + public RxRichTextBlockOverflowEvents(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)> IsTextTrimmedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RowDefinitionEvents + public class RxRowDefinitionEvents { private readonly global::Windows.UI.Xaml.Controls.RowDefinition _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RowDefinitionEvents(global::Windows.UI.Xaml.Controls.RowDefinition data) + public RxRowDefinitionEvents(global::Windows.UI.Xaml.Controls.RowDefinition data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ScrollViewerEvents + public class RxScrollViewerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.ScrollViewer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ScrollViewerEvents(global::Windows.UI.Xaml.Controls.ScrollViewer data) + public RxScrollViewerEvents(global::Windows.UI.Xaml.Controls.ScrollViewer data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args)> AnchorRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AnchorRequested += x, x => _data.AnchorRequested -= x); + }, x => _data.AnchorRequested += x, x => _data.AnchorRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DirectManipulationCompleted => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DirectManipulationCompleted += x, x => _data.DirectManipulationCompleted -= x); + }, x => _data.DirectManipulationCompleted += x, x => _data.DirectManipulationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DirectManipulationStarted => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DirectManipulationStarted += x, x => _data.DirectManipulationStarted -= x); + }, x => _data.DirectManipulationStarted += x, x => _data.DirectManipulationStarted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChanged += x, x => _data.ViewChanged -= x); + }, x => _data.ViewChanged += x, x => _data.ViewChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ViewChanging => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChanging += x, x => _data.ViewChanging -= x); + }, x => _data.ViewChanging += x, x => _data.ViewChanging -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SearchBoxEvents + public class RxSearchBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.SearchBox _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SearchBoxEvents(global::Windows.UI.Xaml.Controls.SearchBox data) + public RxSearchBoxEvents(global::Windows.UI.Xaml.Controls.SearchBox data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args)> PrepareForFocusOnKeyboardInput => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrepareForFocusOnKeyboardInput += x, x => _data.PrepareForFocusOnKeyboardInput -= x); + }, x => _data.PrepareForFocusOnKeyboardInput += x, x => _data.PrepareForFocusOnKeyboardInput -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args)> QueryChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QueryChanged += x, x => _data.QueryChanged -= x); + }, x => _data.QueryChanged += x, x => _data.QueryChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args)> QuerySubmitted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args)> ResultSuggestionChosen => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); + }, x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args)> SuggestionsRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); + }, x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SemanticZoomEvents + public class RxSemanticZoomEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.SemanticZoom _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SemanticZoomEvents(global::Windows.UI.Xaml.Controls.SemanticZoom data) + public RxSemanticZoomEvents(global::Windows.UI.Xaml.Controls.SemanticZoom data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ViewChangeCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChangeCompleted += x, x => _data.ViewChangeCompleted -= x); + }, x => _data.ViewChangeCompleted += x, x => _data.ViewChangeCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ViewChangeStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChangeStarted += x, x => _data.ViewChangeStarted -= x); + }, x => _data.ViewChangeStarted += x, x => _data.ViewChangeStarted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SettingsFlyoutEvents + public class RxSettingsFlyoutEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.SettingsFlyout _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SettingsFlyoutEvents(global::Windows.UI.Xaml.Controls.SettingsFlyout data) + public RxSettingsFlyoutEvents(global::Windows.UI.Xaml.Controls.SettingsFlyout data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable BackClick => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.BackClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackClick += x, x => _data.BackClick -= x); + }, x => _data.BackClick += x, x => _data.BackClick -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SplitButtonEvents + public class RxSplitButtonEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.SplitButton _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SplitButtonEvents(global::Windows.UI.Xaml.Controls.SplitButton data) + public RxSplitButtonEvents(global::Windows.UI.Xaml.Controls.SplitButton data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args)> Click => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SplitViewEvents + public class RxSplitViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.SplitView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SplitViewEvents(global::Windows.UI.Xaml.Controls.SplitView data) + public RxSplitViewEvents(global::Windows.UI.Xaml.Controls.SplitView data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, object args)> PaneClosed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args)> PaneClosing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, object args)> PaneOpened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SplitView sender, object args)> PaneOpening => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SplitView sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class StackPanelEvents + public class RxStackPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents { private readonly global::Windows.UI.Xaml.Controls.StackPanel _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public StackPanelEvents(global::Windows.UI.Xaml.Controls.StackPanel data) + public RxStackPanelEvents(global::Windows.UI.Xaml.Controls.StackPanel data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SwapChainPanelEvents + public class RxSwapChainPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents { private readonly global::Windows.UI.Xaml.Controls.SwapChainPanel _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SwapChainPanelEvents(global::Windows.UI.Xaml.Controls.SwapChainPanel data) + public RxSwapChainPanelEvents(global::Windows.UI.Xaml.Controls.SwapChainPanel data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args)> CompositionScaleChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompositionScaleChanged += x, x => _data.CompositionScaleChanged -= x); + }, x => _data.CompositionScaleChanged += x, x => _data.CompositionScaleChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SwipeItemEvents + public class RxSwipeItemEvents { private readonly global::Windows.UI.Xaml.Controls.SwipeItem _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SwipeItemEvents(global::Windows.UI.Xaml.Controls.SwipeItem data) + public RxSwipeItemEvents(global::Windows.UI.Xaml.Controls.SwipeItem data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SwipeItemsEvents + public class RxSwipeItemsEvents { private readonly global::Windows.UI.Xaml.Controls.SwipeItems _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SwipeItemsEvents(global::Windows.UI.Xaml.Controls.SwipeItems data) + public RxSwipeItemsEvents(global::Windows.UI.Xaml.Controls.SwipeItems data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TextBlockEvents + public class RxTextBlockEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents { private readonly global::Windows.UI.Xaml.Controls.TextBlock _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TextBlockEvents(global::Windows.UI.Xaml.Controls.TextBlock data) + public RxTextBlockEvents(global::Windows.UI.Xaml.Controls.TextBlock data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)> IsTextTrimmedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TextBoxEvents + public class RxTextBoxEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.TextBox _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TextBoxEvents(global::Windows.UI.Xaml.Controls.TextBox data) + public RxTextBoxEvents(global::Windows.UI.Xaml.Controls.TextBox data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args)> BeforeTextChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BeforeTextChanging += x, x => _data.BeforeTextChanging -= x); + }, x => _data.BeforeTextChanging += x, x => _data.BeforeTextChanging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)> CandidateWindowBoundsChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ContextMenuOpening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)> CopyingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)> CuttingToClipboard => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Paste => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paste += x, x => _data.Paste -= x); + }, x => _data.Paste += x, x => _data.Paste -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args)> SelectionChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args)> TextChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextChanging += x, x => _data.TextChanging -= x); + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)> TextCompositionChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)> TextCompositionEnded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)> TextCompositionStarted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TimePickedEventArgsEvents + public class RxTimePickedEventArgsEvents { private readonly global::Windows.UI.Xaml.Controls.TimePickedEventArgs _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TimePickedEventArgsEvents(global::Windows.UI.Xaml.Controls.TimePickedEventArgs data) + public RxTimePickedEventArgsEvents(global::Windows.UI.Xaml.Controls.TimePickedEventArgs data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TimePickerEvents + public class RxTimePickerEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.TimePicker _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TimePickerEvents(global::Windows.UI.Xaml.Controls.TimePicker data) + public RxTimePickerEvents(global::Windows.UI.Xaml.Controls.TimePicker data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args)> SelectedTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedTimeChanged += x, x => _data.SelectedTimeChanged -= x); + }, x => _data.SelectedTimeChanged += x, x => _data.SelectedTimeChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable TimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TimeChanged += x, x => _data.TimeChanged -= x); + }, x => _data.TimeChanged += x, x => _data.TimeChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TimePickerFlyoutEvents + public class RxTimePickerFlyoutEvents : global::Windows.UI.Xaml.Controls.Primitives.RxFlyoutBaseEvents { private readonly global::Windows.UI.Xaml.Controls.TimePickerFlyout _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TimePickerFlyoutEvents(global::Windows.UI.Xaml.Controls.TimePickerFlyout data) + public RxTimePickerFlyoutEvents(global::Windows.UI.Xaml.Controls.TimePickerFlyout data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args)> TimePicked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimePicked += x, x => _data.TimePicked -= x); + }, x => _data.TimePicked += x, x => _data.TimePicked -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ToggleSplitButtonEvents + public class RxToggleSplitButtonEvents : global::Windows.UI.Xaml.Controls.RxSplitButtonEvents { private readonly global::Windows.UI.Xaml.Controls.ToggleSplitButton _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ToggleSplitButtonEvents(global::Windows.UI.Xaml.Controls.ToggleSplitButton data) + public RxToggleSplitButtonEvents(global::Windows.UI.Xaml.Controls.ToggleSplitButton data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args)> IsCheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsCheckedChanged += x, x => _data.IsCheckedChanged -= x); + }, x => _data.IsCheckedChanged += x, x => _data.IsCheckedChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ToggleSwitchEvents + public class RxToggleSwitchEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.ToggleSwitch _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ToggleSwitchEvents(global::Windows.UI.Xaml.Controls.ToggleSwitch data) + public RxToggleSwitchEvents(global::Windows.UI.Xaml.Controls.ToggleSwitch data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ToolTipEvents + public class RxToolTipEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.ToolTip _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ToolTipEvents(global::Windows.UI.Xaml.Controls.ToolTip data) + public RxToolTipEvents(global::Windows.UI.Xaml.Controls.ToolTip data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TreeViewEvents + public class RxTreeViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.TreeView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TreeViewEvents(global::Windows.UI.Xaml.Controls.TreeView data) + public RxTreeViewEvents(global::Windows.UI.Xaml.Controls.TreeView data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args)> Collapsed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Collapsed += x, x => _data.Collapsed -= x); + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args)> DragItemsCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args)> DragItemsStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args)> Expanding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Expanding += x, x => _data.Expanding -= x); + }, x => _data.Expanding += x, x => _data.Expanding -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args)> ItemInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TreeViewItemTemplateSettingsEvents + public class RxTreeViewItemTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.TreeViewItemTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TreeViewItemTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.TreeViewItemTemplateSettings data) + public RxTreeViewItemTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.TreeViewItemTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TreeViewNodeEvents + public class RxTreeViewNodeEvents { private readonly global::Windows.UI.Xaml.Controls.TreeViewNode _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TreeViewNodeEvents(global::Windows.UI.Xaml.Controls.TreeViewNode data) + public RxTreeViewNodeEvents(global::Windows.UI.Xaml.Controls.TreeViewNode data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class VirtualizingPanelLayoutEvents + public class RxVirtualizingPanelLayoutEvents { private readonly global::Windows.UI.Xaml.Controls.VirtualizingPanelLayout _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public VirtualizingPanelLayoutEvents(global::Windows.UI.Xaml.Controls.VirtualizingPanelLayout data) + public RxVirtualizingPanelLayoutEvents(global::Windows.UI.Xaml.Controls.VirtualizingPanelLayout data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class VirtualizingStackPanelEvents + public class RxVirtualizingStackPanelEvents : global::Windows.UI.Xaml.Controls.Primitives.RxOrientedVirtualizingPanelEvents { private readonly global::Windows.UI.Xaml.Controls.VirtualizingStackPanel _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public VirtualizingStackPanelEvents(global::Windows.UI.Xaml.Controls.VirtualizingStackPanel data) + public RxVirtualizingStackPanelEvents(global::Windows.UI.Xaml.Controls.VirtualizingStackPanel data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable CleanUpVirtualizedItemEvent => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CleanUpVirtualizedItemEvent += x, x => _data.CleanUpVirtualizedItemEvent -= x); + }, x => _data.CleanUpVirtualizedItemEvent += x, x => _data.CleanUpVirtualizedItemEvent -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class WebViewEvents + public class RxWebViewEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.WebView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WebViewEvents(global::Windows.UI.Xaml.Controls.WebView data) + public RxWebViewEvents(global::Windows.UI.Xaml.Controls.WebView data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable NavigationFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.WebViewNavigationFailedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.NotifyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args)> SeparateProcessLost => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeparateProcessLost += x, x => _data.SeparateProcessLost -= x); + }, x => _data.SeparateProcessLost += x, x => _data.SeparateProcessLost -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } } @@ -21517,771 +19293,693 @@ namespace Windows.UI.Xaml.Controls.Maps /// /// A wrapper class which wraps all the events contained within the class. /// - public static CustomMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource item) => new CustomMapTileDataSourceEvents(item); + public static RxCustomMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource item) => new RxCustomMapTileDataSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static HttpMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource item) => new HttpMapTileDataSourceEvents(item); + public static RxHttpMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource item) => new RxHttpMapTileDataSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static LocalMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource item) => new LocalMapTileDataSourceEvents(item); + public static RxLocalMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource item) => new RxLocalMapTileDataSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MapCameraEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapCamera item) => new MapCameraEvents(item); + public static RxMapCameraEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapCamera item) => new RxMapCameraEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MapControlEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapControl item) => new MapControlEvents(item); + public static RxMapControlEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapControl item) => new RxMapControlEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MapCustomExperienceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapCustomExperience item) => new MapCustomExperienceEvents(item); + public static RxMapCustomExperienceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapCustomExperience item) => new RxMapCustomExperienceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MapElementEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapElement item) => new MapElementEvents(item); + public static RxMapElementEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapElement item) => new RxMapElementEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MapElementsLayerEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer item) => new MapElementsLayerEvents(item); + public static RxMapElementsLayerEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer item) => new RxMapElementsLayerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MapInputEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs item) => new MapInputEventArgsEvents(item); + public static RxMapInputEventArgsEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs item) => new RxMapInputEventArgsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MapItemsControlEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapItemsControl item) => new MapItemsControlEvents(item); + public static RxMapItemsControlEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapItemsControl item) => new RxMapItemsControlEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MapLayerEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapLayer item) => new MapLayerEvents(item); + public static RxMapLayerEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapLayer item) => new RxMapLayerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MapModel3DEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapModel3D item) => new MapModel3DEvents(item); + public static RxMapModel3DEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapModel3D item) => new RxMapModel3DEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MapRouteViewEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapRouteView item) => new MapRouteViewEvents(item); + public static RxMapRouteViewEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapRouteView item) => new RxMapRouteViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MapSceneEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapScene item) => new MapSceneEvents(item); + public static RxMapSceneEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapScene item) => new RxMapSceneEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MapStyleSheetEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapStyleSheet item) => new MapStyleSheetEvents(item); + public static RxMapStyleSheetEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapStyleSheet item) => new RxMapStyleSheetEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapTileDataSource item) => new MapTileDataSourceEvents(item); + public static RxMapTileDataSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapTileDataSource item) => new RxMapTileDataSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MapTileSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapTileSource item) => new MapTileSourceEvents(item); + public static RxMapTileSourceEvents Events(this global::Windows.UI.Xaml.Controls.Maps.MapTileSource item) => new RxMapTileSourceEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static StreetsidePanoramaEvents Events(this global::Windows.UI.Xaml.Controls.Maps.StreetsidePanorama item) => new StreetsidePanoramaEvents(item); + public static RxStreetsidePanoramaEvents Events(this global::Windows.UI.Xaml.Controls.Maps.StreetsidePanorama item) => new RxStreetsidePanoramaEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class CustomMapTileDataSourceEvents + public class RxCustomMapTileDataSourceEvents : global::Windows.UI.Xaml.Controls.Maps.RxMapTileDataSourceEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CustomMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource data) + public RxCustomMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args)> BitmapRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class HttpMapTileDataSourceEvents + public class RxHttpMapTileDataSourceEvents : global::Windows.UI.Xaml.Controls.Maps.RxMapTileDataSourceEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public HttpMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource data) + public RxHttpMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)> UriRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UriRequested += x, x => _data.UriRequested -= x); + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class LocalMapTileDataSourceEvents + public class RxLocalMapTileDataSourceEvents : global::Windows.UI.Xaml.Controls.Maps.RxMapTileDataSourceEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public LocalMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource data) + public RxLocalMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)> UriRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UriRequested += x, x => _data.UriRequested -= x); + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MapCameraEvents + public class RxMapCameraEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.MapCamera _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MapCameraEvents(global::Windows.UI.Xaml.Controls.Maps.MapCamera data) + public RxMapCameraEvents(global::Windows.UI.Xaml.Controls.Maps.MapCamera data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MapControlEvents + public class RxMapControlEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.MapControl _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MapControlEvents(global::Windows.UI.Xaml.Controls.Maps.MapControl data) + public RxMapControlEvents(global::Windows.UI.Xaml.Controls.Maps.MapControl data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args)> ActualCameraChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActualCameraChanged += x, x => _data.ActualCameraChanged -= x); + }, x => _data.ActualCameraChanged += x, x => _data.ActualCameraChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args)> ActualCameraChanging => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActualCameraChanging += x, x => _data.ActualCameraChanging -= x); + }, x => _data.ActualCameraChanging += x, x => _data.ActualCameraChanging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> CenterChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CenterChanged += x, x => _data.CenterChanged -= x); + }, x => _data.CenterChanged += x, x => _data.CenterChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args)> CustomExperienceChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CustomExperienceChanged += x, x => _data.CustomExperienceChanged -= x); + }, x => _data.CustomExperienceChanged += x, x => _data.CustomExperienceChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> HeadingChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadingChanged += x, x => _data.HeadingChanged -= x); + }, x => _data.HeadingChanged += x, x => _data.HeadingChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> LoadingStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoadingStatusChanged += x, x => _data.LoadingStatusChanged -= x); + }, x => _data.LoadingStatusChanged += x, x => _data.LoadingStatusChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args)> MapContextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)> MapDoubleTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapDoubleTapped += x, x => _data.MapDoubleTapped -= x); + }, x => _data.MapDoubleTapped += x, x => _data.MapDoubleTapped -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args)> MapElementClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args)> MapElementPointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args)> MapElementPointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)> MapHolding => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapHolding += x, x => _data.MapHolding -= x); + }, x => _data.MapHolding += x, x => _data.MapHolding -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args)> MapRightTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapRightTapped += x, x => _data.MapRightTapped -= x); + }, x => _data.MapRightTapped += x, x => _data.MapRightTapped -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)> MapTapped => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapTapped += x, x => _data.MapTapped -= x); + }, x => _data.MapTapped += x, x => _data.MapTapped -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> PitchChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PitchChanged += x, x => _data.PitchChanged -= x); + }, x => _data.PitchChanged += x, x => _data.PitchChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)> TargetCameraChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> TransformOriginChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TransformOriginChanged += x, x => _data.TransformOriginChanged -= x); + }, x => _data.TransformOriginChanged += x, x => _data.TransformOriginChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)> ZoomLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ZoomLevelChanged += x, x => _data.ZoomLevelChanged -= x); + }, x => _data.ZoomLevelChanged += x, x => _data.ZoomLevelChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MapCustomExperienceEvents + public class RxMapCustomExperienceEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.MapCustomExperience _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MapCustomExperienceEvents(global::Windows.UI.Xaml.Controls.Maps.MapCustomExperience data) + public RxMapCustomExperienceEvents(global::Windows.UI.Xaml.Controls.Maps.MapCustomExperience data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MapElementEvents + public class RxMapElementEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.MapElement _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MapElementEvents(global::Windows.UI.Xaml.Controls.Maps.MapElement data) + public RxMapElementEvents(global::Windows.UI.Xaml.Controls.Maps.MapElement data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MapElementsLayerEvents + public class RxMapElementsLayerEvents : global::Windows.UI.Xaml.Controls.Maps.RxMapLayerEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MapElementsLayerEvents(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer data) + public RxMapElementsLayerEvents(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args)> MapContextRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args)> MapElementClick => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args)> MapElementPointerEntered => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args)> MapElementPointerExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MapInputEventArgsEvents + public class RxMapInputEventArgsEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MapInputEventArgsEvents(global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs data) + public RxMapInputEventArgsEvents(global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MapItemsControlEvents + public class RxMapItemsControlEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.MapItemsControl _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MapItemsControlEvents(global::Windows.UI.Xaml.Controls.Maps.MapItemsControl data) + public RxMapItemsControlEvents(global::Windows.UI.Xaml.Controls.Maps.MapItemsControl data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MapLayerEvents + public class RxMapLayerEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.MapLayer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MapLayerEvents(global::Windows.UI.Xaml.Controls.Maps.MapLayer data) + public RxMapLayerEvents(global::Windows.UI.Xaml.Controls.Maps.MapLayer data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MapModel3DEvents + public class RxMapModel3DEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.MapModel3D _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MapModel3DEvents(global::Windows.UI.Xaml.Controls.Maps.MapModel3D data) + public RxMapModel3DEvents(global::Windows.UI.Xaml.Controls.Maps.MapModel3D data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MapRouteViewEvents + public class RxMapRouteViewEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.MapRouteView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MapRouteViewEvents(global::Windows.UI.Xaml.Controls.Maps.MapRouteView data) + public RxMapRouteViewEvents(global::Windows.UI.Xaml.Controls.Maps.MapRouteView data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MapSceneEvents + public class RxMapSceneEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.MapScene _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MapSceneEvents(global::Windows.UI.Xaml.Controls.Maps.MapScene data) + public RxMapSceneEvents(global::Windows.UI.Xaml.Controls.Maps.MapScene data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)> TargetCameraChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MapStyleSheetEvents + public class RxMapStyleSheetEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.MapStyleSheet _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MapStyleSheetEvents(global::Windows.UI.Xaml.Controls.Maps.MapStyleSheet data) + public RxMapStyleSheetEvents(global::Windows.UI.Xaml.Controls.Maps.MapStyleSheet data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MapTileDataSourceEvents + public class RxMapTileDataSourceEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.MapTileDataSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.MapTileDataSource data) + public RxMapTileDataSourceEvents(global::Windows.UI.Xaml.Controls.Maps.MapTileDataSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MapTileSourceEvents + public class RxMapTileSourceEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.MapTileSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MapTileSourceEvents(global::Windows.UI.Xaml.Controls.Maps.MapTileSource data) + public RxMapTileSourceEvents(global::Windows.UI.Xaml.Controls.Maps.MapTileSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class StreetsidePanoramaEvents + public class RxStreetsidePanoramaEvents { private readonly global::Windows.UI.Xaml.Controls.Maps.StreetsidePanorama _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public StreetsidePanoramaEvents(global::Windows.UI.Xaml.Controls.Maps.StreetsidePanorama data) + public RxStreetsidePanoramaEvents(global::Windows.UI.Xaml.Controls.Maps.StreetsidePanorama data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -22295,1197 +19993,1235 @@ namespace Windows.UI.Xaml.Controls.Primitives /// /// A wrapper class which wraps all the events contained within the class. /// - public static AppBarButtonTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.AppBarButtonTemplateSettings item) => new AppBarButtonTemplateSettingsEvents(item); + public static RxAppBarButtonTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.AppBarButtonTemplateSettings item) => new RxAppBarButtonTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AppBarTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.AppBarTemplateSettings item) => new AppBarTemplateSettingsEvents(item); + public static RxAppBarTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.AppBarTemplateSettings item) => new RxAppBarTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static AppBarToggleButtonTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.AppBarToggleButtonTemplateSettings item) => new AppBarToggleButtonTemplateSettingsEvents(item); + public static RxAppBarToggleButtonTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.AppBarToggleButtonTemplateSettings item) => new RxAppBarToggleButtonTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ButtonBaseEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ButtonBase item) => new ButtonBaseEvents(item); + public static RxButtonBaseEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ButtonBase item) => new RxButtonBaseEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CalendarViewTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.CalendarViewTemplateSettings item) => new CalendarViewTemplateSettingsEvents(item); + public static RxCalendarViewTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.CalendarViewTemplateSettings item) => new RxCalendarViewTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CarouselPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.CarouselPanel item) => new CarouselPanelEvents(item); + public static RxCarouselPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.CarouselPanel item) => new RxCarouselPanelEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ColorSpectrumEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum item) => new ColorSpectrumEvents(item); + public static RxColorSpectrumEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum item) => new RxColorSpectrumEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ComboBoxTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ComboBoxTemplateSettings item) => new ComboBoxTemplateSettingsEvents(item); + public static RxComboBoxTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ComboBoxTemplateSettings item) => new RxComboBoxTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CommandBarFlyoutCommandBarTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.CommandBarFlyoutCommandBarTemplateSettings item) => new CommandBarFlyoutCommandBarTemplateSettingsEvents(item); + public static RxCommandBarFlyoutCommandBarTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.CommandBarFlyoutCommandBarTemplateSettings item) => new RxCommandBarFlyoutCommandBarTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CommandBarTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.CommandBarTemplateSettings item) => new CommandBarTemplateSettingsEvents(item); + public static RxCommandBarTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.CommandBarTemplateSettings item) => new RxCommandBarTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static FlyoutBaseEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase item) => new FlyoutBaseEvents(item); + public static RxFlyoutBaseEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase item) => new RxFlyoutBaseEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static GridViewItemTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.GridViewItemTemplateSettings item) => new GridViewItemTemplateSettingsEvents(item); + public static RxGridViewItemTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.GridViewItemTemplateSettings item) => new RxGridViewItemTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IScrollSnapPointsInfoEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo item) => new IScrollSnapPointsInfoEvents(item); + public static RxIScrollSnapPointsInfoEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo item) => new RxIScrollSnapPointsInfoEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static JumpListItemBackgroundConverterEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.JumpListItemBackgroundConverter item) => new JumpListItemBackgroundConverterEvents(item); + public static RxJumpListItemBackgroundConverterEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.JumpListItemBackgroundConverter item) => new RxJumpListItemBackgroundConverterEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static JumpListItemForegroundConverterEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.JumpListItemForegroundConverter item) => new JumpListItemForegroundConverterEvents(item); + public static RxJumpListItemForegroundConverterEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.JumpListItemForegroundConverter item) => new RxJumpListItemForegroundConverterEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ListViewItemTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ListViewItemTemplateSettings item) => new ListViewItemTemplateSettingsEvents(item); + public static RxListViewItemTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ListViewItemTemplateSettings item) => new RxListViewItemTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static LoopingSelectorEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.LoopingSelector item) => new LoopingSelectorEvents(item); + public static RxLoopingSelectorEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.LoopingSelector item) => new RxLoopingSelectorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static LoopingSelectorPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.LoopingSelectorPanel item) => new LoopingSelectorPanelEvents(item); + public static RxLoopingSelectorPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.LoopingSelectorPanel item) => new RxLoopingSelectorPanelEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MenuFlyoutItemTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.MenuFlyoutItemTemplateSettings item) => new MenuFlyoutItemTemplateSettingsEvents(item); + public static RxMenuFlyoutItemTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.MenuFlyoutItemTemplateSettings item) => new RxMenuFlyoutItemTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MenuFlyoutPresenterTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.MenuFlyoutPresenterTemplateSettings item) => new MenuFlyoutPresenterTemplateSettingsEvents(item); + public static RxMenuFlyoutPresenterTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.MenuFlyoutPresenterTemplateSettings item) => new RxMenuFlyoutPresenterTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static OrientedVirtualizingPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel item) => new OrientedVirtualizingPanelEvents(item); + public static RxOrientedVirtualizingPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel item) => new RxOrientedVirtualizingPanelEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PivotPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.PivotPanel item) => new PivotPanelEvents(item); + public static RxPivotPanelEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.PivotPanel item) => new RxPivotPanelEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PopupEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.Popup item) => new PopupEvents(item); + public static RxPopupEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.Popup item) => new RxPopupEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ProgressBarTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ProgressBarTemplateSettings item) => new ProgressBarTemplateSettingsEvents(item); + public static RxProgressBarTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ProgressBarTemplateSettings item) => new RxProgressBarTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ProgressRingTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ProgressRingTemplateSettings item) => new ProgressRingTemplateSettingsEvents(item); + public static RxProgressRingTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ProgressRingTemplateSettings item) => new RxProgressRingTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RangeBaseEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.RangeBase item) => new RangeBaseEvents(item); + public static RxRangeBaseEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.RangeBase item) => new RxRangeBaseEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ScrollBarEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ScrollBar item) => new ScrollBarEvents(item); + public static RxScrollBarEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ScrollBar item) => new RxScrollBarEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SelectorEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.Selector item) => new SelectorEvents(item); + public static RxSelectorEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.Selector item) => new RxSelectorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SettingsFlyoutTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.SettingsFlyoutTemplateSettings item) => new SettingsFlyoutTemplateSettingsEvents(item); + public static RxSettingsFlyoutTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.SettingsFlyoutTemplateSettings item) => new RxSettingsFlyoutTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SplitViewTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.SplitViewTemplateSettings item) => new SplitViewTemplateSettingsEvents(item); + public static RxSplitViewTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.SplitViewTemplateSettings item) => new RxSplitViewTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ThumbEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.Thumb item) => new ThumbEvents(item); + public static RxThumbEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.Thumb item) => new RxThumbEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ToggleButtonEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ToggleButton item) => new ToggleButtonEvents(item); + public static RxToggleButtonEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ToggleButton item) => new RxToggleButtonEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ToggleSwitchTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ToggleSwitchTemplateSettings item) => new ToggleSwitchTemplateSettingsEvents(item); + public static RxToggleSwitchTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ToggleSwitchTemplateSettings item) => new RxToggleSwitchTemplateSettingsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ToolTipTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ToolTipTemplateSettings item) => new ToolTipTemplateSettingsEvents(item); + public static RxToolTipTemplateSettingsEvents Events(this global::Windows.UI.Xaml.Controls.Primitives.ToolTipTemplateSettings item) => new RxToolTipTemplateSettingsEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class AppBarButtonTemplateSettingsEvents + public class RxAppBarButtonTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.AppBarButtonTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AppBarButtonTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.AppBarButtonTemplateSettings data) + public RxAppBarButtonTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.AppBarButtonTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AppBarTemplateSettingsEvents + public class RxAppBarTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.AppBarTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AppBarTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.AppBarTemplateSettings data) + public RxAppBarTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.AppBarTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class AppBarToggleButtonTemplateSettingsEvents + public class RxAppBarToggleButtonTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.AppBarToggleButtonTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public AppBarToggleButtonTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.AppBarToggleButtonTemplateSettings data) + public RxAppBarToggleButtonTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.AppBarToggleButtonTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ButtonBaseEvents + public class RxButtonBaseEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.ButtonBase _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ButtonBaseEvents(global::Windows.UI.Xaml.Controls.Primitives.ButtonBase data) + public RxButtonBaseEvents(global::Windows.UI.Xaml.Controls.Primitives.ButtonBase data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CalendarViewTemplateSettingsEvents + public class RxCalendarViewTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.CalendarViewTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CalendarViewTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.CalendarViewTemplateSettings data) + public RxCalendarViewTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.CalendarViewTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CarouselPanelEvents + public class RxCarouselPanelEvents : global::Windows.UI.Xaml.Controls.RxStackPanelEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.CarouselPanel _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CarouselPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.CarouselPanel data) + public RxCarouselPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.CarouselPanel data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ColorSpectrumEvents + public class RxColorSpectrumEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ColorSpectrumEvents(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum data) + public RxColorSpectrumEvents(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)> ColorChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ComboBoxTemplateSettingsEvents + public class RxComboBoxTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.ComboBoxTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ComboBoxTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.ComboBoxTemplateSettings data) + public RxComboBoxTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.ComboBoxTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CommandBarFlyoutCommandBarTemplateSettingsEvents + public class RxCommandBarFlyoutCommandBarTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.CommandBarFlyoutCommandBarTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CommandBarFlyoutCommandBarTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.CommandBarFlyoutCommandBarTemplateSettings data) + public RxCommandBarFlyoutCommandBarTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.CommandBarFlyoutCommandBarTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CommandBarTemplateSettingsEvents + public class RxCommandBarTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.CommandBarTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CommandBarTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.CommandBarTemplateSettings data) + public RxCommandBarTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.CommandBarTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class FlyoutBaseEvents + public class RxFlyoutBaseEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public FlyoutBaseEvents(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase data) + public RxFlyoutBaseEvents(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args)> Closing => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Opening => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opening += x, x => _data.Opening -= x); + }, x => _data.Opening += x, x => _data.Opening -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GridViewItemTemplateSettingsEvents + public class RxGridViewItemTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.GridViewItemTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GridViewItemTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.GridViewItemTemplateSettings data) + public RxGridViewItemTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.GridViewItemTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IScrollSnapPointsInfoEvents + public class RxIScrollSnapPointsInfoEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IScrollSnapPointsInfoEvents(global::Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo data) + public RxIScrollSnapPointsInfoEvents(global::Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class JumpListItemBackgroundConverterEvents + public class RxJumpListItemBackgroundConverterEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.JumpListItemBackgroundConverter _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public JumpListItemBackgroundConverterEvents(global::Windows.UI.Xaml.Controls.Primitives.JumpListItemBackgroundConverter data) + public RxJumpListItemBackgroundConverterEvents(global::Windows.UI.Xaml.Controls.Primitives.JumpListItemBackgroundConverter data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class JumpListItemForegroundConverterEvents + public class RxJumpListItemForegroundConverterEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.JumpListItemForegroundConverter _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public JumpListItemForegroundConverterEvents(global::Windows.UI.Xaml.Controls.Primitives.JumpListItemForegroundConverter data) + public RxJumpListItemForegroundConverterEvents(global::Windows.UI.Xaml.Controls.Primitives.JumpListItemForegroundConverter data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ListViewItemTemplateSettingsEvents + public class RxListViewItemTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.ListViewItemTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ListViewItemTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.ListViewItemTemplateSettings data) + public RxListViewItemTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.ListViewItemTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class LoopingSelectorEvents + public class RxLoopingSelectorEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.LoopingSelector _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public LoopingSelectorEvents(global::Windows.UI.Xaml.Controls.Primitives.LoopingSelector data) + public RxLoopingSelectorEvents(global::Windows.UI.Xaml.Controls.Primitives.LoopingSelector data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class LoopingSelectorPanelEvents + public class RxLoopingSelectorPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.LoopingSelectorPanel _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public LoopingSelectorPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.LoopingSelectorPanel data) + public RxLoopingSelectorPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.LoopingSelectorPanel data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MenuFlyoutItemTemplateSettingsEvents + public class RxMenuFlyoutItemTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.MenuFlyoutItemTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MenuFlyoutItemTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.MenuFlyoutItemTemplateSettings data) + public RxMenuFlyoutItemTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.MenuFlyoutItemTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MenuFlyoutPresenterTemplateSettingsEvents + public class RxMenuFlyoutPresenterTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.MenuFlyoutPresenterTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MenuFlyoutPresenterTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.MenuFlyoutPresenterTemplateSettings data) + public RxMenuFlyoutPresenterTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.MenuFlyoutPresenterTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class OrientedVirtualizingPanelEvents + public class RxOrientedVirtualizingPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public OrientedVirtualizingPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel data) + public RxOrientedVirtualizingPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PivotPanelEvents + public class RxPivotPanelEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.PivotPanel _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PivotPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.PivotPanel data) + public RxPivotPanelEvents(global::Windows.UI.Xaml.Controls.Primitives.PivotPanel data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable HorizontalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable VerticalSnapPointsChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PopupEvents + public class RxPopupEvents : global::Windows.UI.Xaml.RxFrameworkElementEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.Popup _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PopupEvents(global::Windows.UI.Xaml.Controls.Primitives.Popup data) + public RxPopupEvents(global::Windows.UI.Xaml.Controls.Primitives.Popup data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Closed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Opened => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ProgressBarTemplateSettingsEvents + public class RxProgressBarTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.ProgressBarTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ProgressBarTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.ProgressBarTemplateSettings data) + public RxProgressBarTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.ProgressBarTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ProgressRingTemplateSettingsEvents + public class RxProgressRingTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.ProgressRingTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ProgressRingTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.ProgressRingTemplateSettings data) + public RxProgressRingTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.ProgressRingTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RangeBaseEvents + public class RxRangeBaseEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.RangeBase _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RangeBaseEvents(global::Windows.UI.Xaml.Controls.Primitives.RangeBase data) + public RxRangeBaseEvents(global::Windows.UI.Xaml.Controls.Primitives.RangeBase data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ScrollBarEvents + public class RxScrollBarEvents : global::Windows.UI.Xaml.Controls.Primitives.RxRangeBaseEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.ScrollBar _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ScrollBarEvents(global::Windows.UI.Xaml.Controls.Primitives.ScrollBar data) + public RxScrollBarEvents(global::Windows.UI.Xaml.Controls.Primitives.ScrollBar data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Scroll => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scroll += x, x => _data.Scroll -= x); + }, x => _data.Scroll += x, x => _data.Scroll -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SelectorEvents + public class RxSelectorEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.Selector _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SelectorEvents(global::Windows.UI.Xaml.Controls.Primitives.Selector data) + public RxSelectorEvents(global::Windows.UI.Xaml.Controls.Primitives.Selector data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SettingsFlyoutTemplateSettingsEvents + public class RxSettingsFlyoutTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.SettingsFlyoutTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SettingsFlyoutTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.SettingsFlyoutTemplateSettings data) + public RxSettingsFlyoutTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.SettingsFlyoutTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SplitViewTemplateSettingsEvents + public class RxSplitViewTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.SplitViewTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SplitViewTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.SplitViewTemplateSettings data) + public RxSplitViewTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.SplitViewTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ThumbEvents + public class RxThumbEvents : global::Windows.UI.Xaml.Controls.RxControlEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.Thumb _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ThumbEvents(global::Windows.UI.Xaml.Controls.Primitives.Thumb data) + public RxThumbEvents(global::Windows.UI.Xaml.Controls.Primitives.Thumb data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DragDelta => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragDelta += x, x => _data.DragDelta -= x); + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ToggleButtonEvents + public class RxToggleButtonEvents : global::Windows.UI.Xaml.Controls.Primitives.RxButtonBaseEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.ToggleButton _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ToggleButtonEvents(global::Windows.UI.Xaml.Controls.Primitives.ToggleButton data) + public RxToggleButtonEvents(global::Windows.UI.Xaml.Controls.Primitives.ToggleButton data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Checked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Checked += x, x => _data.Checked -= x); + }, x => _data.Checked += x, x => _data.Checked -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Indeterminate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Unchecked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unchecked += x, x => _data.Unchecked -= x); + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ToggleSwitchTemplateSettingsEvents + public class RxToggleSwitchTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.ToggleSwitchTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ToggleSwitchTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.ToggleSwitchTemplateSettings data) + public RxToggleSwitchTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.ToggleSwitchTemplateSettings data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ToolTipTemplateSettingsEvents + public class RxToolTipTemplateSettingsEvents { private readonly global::Windows.UI.Xaml.Controls.Primitives.ToolTipTemplateSettings _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ToolTipTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.ToolTipTemplateSettings data) + public RxToolTipTemplateSettingsEvents(global::Windows.UI.Xaml.Controls.Primitives.ToolTipTemplateSettings data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + } +} + +namespace Windows.UI.Xaml.Data +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBindingBaseEvents Events(this global::Windows.UI.Xaml.Data.BindingBase item) => new RxBindingBaseEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCollectionViewSourceEvents Events(this global::Windows.UI.Xaml.Data.CollectionViewSource item) => new RxCollectionViewSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxElementNameSubjectEvents Events(this global::Windows.UI.Xaml.Data.ElementNameSubject item) => new RxElementNameSubjectEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxICollectionViewEvents Events(this global::Windows.UI.Xaml.Data.ICollectionView item) => new RxICollectionViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBindingBaseEvents + { + private readonly global::Windows.UI.Xaml.Data.BindingBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBindingBaseEvents(global::Windows.UI.Xaml.Data.BindingBase data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCollectionViewSourceEvents + { + private readonly global::Windows.UI.Xaml.Data.CollectionViewSource _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCollectionViewSourceEvents(global::Windows.UI.Xaml.Data.CollectionViewSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxElementNameSubjectEvents + { + private readonly global::Windows.UI.Xaml.Data.ElementNameSubject _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxElementNameSubjectEvents(global::Windows.UI.Xaml.Data.ElementNameSubject data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ElementInstanceChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, object instance) => eventHandler(instance); + return Handler; + }, x => _data.ElementInstanceChanged += x, x => _data.ElementInstanceChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxICollectionViewEvents + { + private readonly global::Windows.UI.Xaml.Data.ICollectionView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxICollectionViewEvents(global::Windows.UI.Xaml.Data.ICollectionView data) + { + _data = data; } - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CurrentChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Data.CurrentChangingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); } } @@ -23499,621 +21235,772 @@ namespace Windows.UI.Xaml.Documents /// /// A wrapper class which wraps all the events contained within the class. /// - public static ContentLinkEvents Events(this global::Windows.UI.Xaml.Documents.ContentLink item) => new ContentLinkEvents(item); + public static RxContentLinkEvents Events(this global::Windows.UI.Xaml.Documents.ContentLink item) => new RxContentLinkEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ContentLinkProviderEvents Events(this global::Windows.UI.Xaml.Documents.ContentLinkProvider item) => new ContentLinkProviderEvents(item); + public static RxContentLinkProviderEvents Events(this global::Windows.UI.Xaml.Documents.ContentLinkProvider item) => new RxContentLinkProviderEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static HyperlinkEvents Events(this global::Windows.UI.Xaml.Documents.Hyperlink item) => new HyperlinkEvents(item); + public static RxHyperlinkEvents Events(this global::Windows.UI.Xaml.Documents.Hyperlink item) => new RxHyperlinkEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TextElementEvents Events(this global::Windows.UI.Xaml.Documents.TextElement item) => new TextElementEvents(item); + public static RxTextElementEvents Events(this global::Windows.UI.Xaml.Documents.TextElement item) => new RxTextElementEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TextHighlighterBaseEvents Events(this global::Windows.UI.Xaml.Documents.TextHighlighterBase item) => new TextHighlighterBaseEvents(item); + public static RxTextHighlighterBaseEvents Events(this global::Windows.UI.Xaml.Documents.TextHighlighterBase item) => new RxTextHighlighterBaseEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ContentLinkEvents + public class RxContentLinkEvents : global::Windows.UI.Xaml.Documents.RxTextElementEvents { private readonly global::Windows.UI.Xaml.Documents.ContentLink _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ContentLinkEvents(global::Windows.UI.Xaml.Documents.ContentLink data) + public RxContentLinkEvents(global::Windows.UI.Xaml.Documents.ContentLink data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable GotFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable LostFocus => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ContentLinkProviderEvents + public class RxContentLinkProviderEvents { private readonly global::Windows.UI.Xaml.Documents.ContentLinkProvider _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ContentLinkProviderEvents(global::Windows.UI.Xaml.Documents.ContentLinkProvider data) + public RxContentLinkProviderEvents(global::Windows.UI.Xaml.Documents.ContentLinkProvider data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class HyperlinkEvents + public class RxHyperlinkEvents : global::Windows.UI.Xaml.Documents.RxTextElementEvents { private readonly global::Windows.UI.Xaml.Documents.Hyperlink _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public HyperlinkEvents(global::Windows.UI.Xaml.Documents.Hyperlink data) + public RxHyperlinkEvents(global::Windows.UI.Xaml.Documents.Hyperlink data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args)> Click => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TextElementEvents + public class RxTextElementEvents : global::Windows.UI.Xaml.RxUIElementEvents { private readonly global::Windows.UI.Xaml.Documents.TextElement _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TextElementEvents(global::Windows.UI.Xaml.Documents.TextElement data) + public RxTextElementEvents(global::Windows.UI.Xaml.Documents.TextElement data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)> AccessKeyDisplayDismissed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)> AccessKeyDisplayRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)> AccessKeyInvoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TextHighlighterBaseEvents + public class RxTextHighlighterBaseEvents { private readonly global::Windows.UI.Xaml.Documents.TextHighlighterBase _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TextHighlighterBaseEvents(global::Windows.UI.Xaml.Documents.TextHighlighterBase data) + public RxTextHighlighterBaseEvents(global::Windows.UI.Xaml.Documents.TextHighlighterBase data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } -namespace Windows.UI.Xaml.Media +namespace Windows.UI.Xaml.Input { /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// A class that contains extension methods to wrap events for classes contained within the namespace. /// public static class EventExtensions { /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BrushEvents Events(this global::Windows.UI.Xaml.Media.Brush item) => new BrushEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CacheModeEvents Events(this global::Windows.UI.Xaml.Media.CacheMode item) => new CacheModeEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static GeneralTransformEvents Events(this global::Windows.UI.Xaml.Media.GeneralTransform item) => new GeneralTransformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static GeometryEvents Events(this global::Windows.UI.Xaml.Media.Geometry item) => new GeometryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static GradientStopEvents Events(this global::Windows.UI.Xaml.Media.GradientStop item) => new GradientStopEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageBrushEvents Events(this global::Windows.UI.Xaml.Media.ImageBrush item) => new ImageBrushEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageSourceEvents Events(this global::Windows.UI.Xaml.Media.ImageSource item) => new ImageSourceEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LoadedImageSurfaceEvents Events(this global::Windows.UI.Xaml.Media.LoadedImageSurface item) => new LoadedImageSurfaceEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PathFigureEvents Events(this global::Windows.UI.Xaml.Media.PathFigure item) => new PathFigureEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. + /// A wrapper class which wraps all the events contained within the class. /// - public static PathSegmentEvents Events(this global::Windows.UI.Xaml.Media.PathSegment item) => new PathSegmentEvents(item); + public static RxInputScopeEvents Events(this global::Windows.UI.Xaml.Input.InputScope item) => new RxInputScopeEvents(item); /// - /// A wrapper class which wraps all the events contained within the class. + /// A wrapper class which wraps all the events contained within the class. /// - public static ProjectionEvents Events(this global::Windows.UI.Xaml.Media.Projection item) => new ProjectionEvents(item); + public static RxInputScopeNameEvents Events(this global::Windows.UI.Xaml.Input.InputScopeName item) => new RxInputScopeNameEvents(item); /// - /// A wrapper class which wraps all the events contained within the class. + /// A wrapper class which wraps all the events contained within the class. /// - public static TimelineMarkerEvents Events(this global::Windows.UI.Xaml.Media.TimelineMarker item) => new TimelineMarkerEvents(item); + public static RxKeyboardAcceleratorEvents Events(this global::Windows.UI.Xaml.Input.KeyboardAccelerator item) => new RxKeyboardAcceleratorEvents(item); /// - /// A wrapper class which wraps all the events contained within the class. + /// A wrapper class which wraps all the events contained within the class. /// - public static XamlLightEvents Events(this global::Windows.UI.Xaml.Media.XamlLight item) => new XamlLightEvents(item); + public static RxXamlUICommandEvents Events(this global::Windows.UI.Xaml.Input.XamlUICommand item) => new RxXamlUICommandEvents(item); } /// - /// A class which wraps the events contained within the class as observables. + /// A class which wraps the events contained within the class as observables. /// - public class BrushEvents + public class RxInputScopeEvents { - private readonly global::Windows.UI.Xaml.Media.Brush _data; + private readonly global::Windows.UI.Xaml.Input.InputScope _data; /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BrushEvents(global::Windows.UI.Xaml.Media.Brush data) + public RxInputScopeEvents(global::Windows.UI.Xaml.Input.InputScope data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// - /// A class which wraps the events contained within the class as observables. + /// A class which wraps the events contained within the class as observables. /// - public class CacheModeEvents + public class RxInputScopeNameEvents { - private readonly global::Windows.UI.Xaml.Media.CacheMode _data; + private readonly global::Windows.UI.Xaml.Input.InputScopeName _data; /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CacheModeEvents(global::Windows.UI.Xaml.Media.CacheMode data) + public RxInputScopeNameEvents(global::Windows.UI.Xaml.Input.InputScopeName data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// - /// A class which wraps the events contained within the class as observables. + /// A class which wraps the events contained within the class as observables. /// - public class GeneralTransformEvents + public class RxKeyboardAcceleratorEvents { - private readonly global::Windows.UI.Xaml.Media.GeneralTransform _data; + private readonly global::Windows.UI.Xaml.Input.KeyboardAccelerator _data; /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GeneralTransformEvents(global::Windows.UI.Xaml.Media.GeneralTransform data) + public RxKeyboardAcceleratorEvents(global::Windows.UI.Xaml.Input.KeyboardAccelerator data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args)> Invoked => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.Invoked += x, x => _data.Invoked -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxXamlUICommandEvents + { + private readonly global::Windows.UI.Xaml.Input.XamlUICommand _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxXamlUICommandEvents(global::Windows.UI.Xaml.Input.XamlUICommand data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args)> CanExecuteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.CanExecuteRequested += x, x => _data.CanExecuteRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args)> ExecuteRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.ExecuteRequested += x, x => _data.ExecuteRequested -= x); + } +} + +namespace Windows.UI.Xaml.Interop +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIBindableObservableVectorEvents Events(this global::Windows.UI.Xaml.Interop.IBindableObservableVector item) => new RxIBindableObservableVectorEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIBindableObservableVectorEvents + { + private readonly global::Windows.UI.Xaml.Interop.IBindableObservableVector _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIBindableObservableVectorEvents(global::Windows.UI.Xaml.Interop.IBindableObservableVector data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.Interop.IBindableObservableVector vector, object e)> VectorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(global::Windows.UI.Xaml.Interop.IBindableObservableVector vector, object e) => eventHandler((vector, e)); + return Handler; + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + } +} + +namespace Windows.UI.Xaml.Media +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxBrushEvents Events(this global::Windows.UI.Xaml.Media.Brush item) => new RxBrushEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxCacheModeEvents Events(this global::Windows.UI.Xaml.Media.CacheMode item) => new RxCacheModeEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGeneralTransformEvents Events(this global::Windows.UI.Xaml.Media.GeneralTransform item) => new RxGeneralTransformEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGeometryEvents Events(this global::Windows.UI.Xaml.Media.Geometry item) => new RxGeometryEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxGradientStopEvents Events(this global::Windows.UI.Xaml.Media.GradientStop item) => new RxGradientStopEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageBrushEvents Events(this global::Windows.UI.Xaml.Media.ImageBrush item) => new RxImageBrushEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxImageSourceEvents Events(this global::Windows.UI.Xaml.Media.ImageSource item) => new RxImageSourceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxLoadedImageSurfaceEvents Events(this global::Windows.UI.Xaml.Media.LoadedImageSurface item) => new RxLoadedImageSurfaceEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPathFigureEvents Events(this global::Windows.UI.Xaml.Media.PathFigure item) => new RxPathFigureEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxPathSegmentEvents Events(this global::Windows.UI.Xaml.Media.PathSegment item) => new RxPathSegmentEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxProjectionEvents Events(this global::Windows.UI.Xaml.Media.Projection item) => new RxProjectionEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxTimelineMarkerEvents Events(this global::Windows.UI.Xaml.Media.TimelineMarker item) => new RxTimelineMarkerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxXamlLightEvents Events(this global::Windows.UI.Xaml.Media.XamlLight item) => new RxXamlLightEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxBrushEvents + { + private readonly global::Windows.UI.Xaml.Media.Brush _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxBrushEvents(global::Windows.UI.Xaml.Media.Brush data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxCacheModeEvents + { + private readonly global::Windows.UI.Xaml.Media.CacheMode _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxCacheModeEvents(global::Windows.UI.Xaml.Media.CacheMode data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxGeneralTransformEvents + { + private readonly global::Windows.UI.Xaml.Media.GeneralTransform _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxGeneralTransformEvents(global::Windows.UI.Xaml.Media.GeneralTransform data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => + { + void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); + return Handler; + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GeometryEvents + public class RxGeometryEvents { private readonly global::Windows.UI.Xaml.Media.Geometry _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GeometryEvents(global::Windows.UI.Xaml.Media.Geometry data) + public RxGeometryEvents(global::Windows.UI.Xaml.Media.Geometry data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class GradientStopEvents + public class RxGradientStopEvents { private readonly global::Windows.UI.Xaml.Media.GradientStop _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public GradientStopEvents(global::Windows.UI.Xaml.Media.GradientStop data) + public RxGradientStopEvents(global::Windows.UI.Xaml.Media.GradientStop data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ImageBrushEvents + public class RxImageBrushEvents : global::Windows.UI.Xaml.Media.RxBrushEvents { private readonly global::Windows.UI.Xaml.Media.ImageBrush _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ImageBrushEvents(global::Windows.UI.Xaml.Media.ImageBrush data) + public RxImageBrushEvents(global::Windows.UI.Xaml.Media.ImageBrush data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ImageOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ImageSourceEvents + public class RxImageSourceEvents { private readonly global::Windows.UI.Xaml.Media.ImageSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ImageSourceEvents(global::Windows.UI.Xaml.Media.ImageSource data) + public RxImageSourceEvents(global::Windows.UI.Xaml.Media.ImageSource data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class LoadedImageSurfaceEvents + public class RxLoadedImageSurfaceEvents { private readonly global::Windows.UI.Xaml.Media.LoadedImageSurface _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public LoadedImageSurfaceEvents(global::Windows.UI.Xaml.Media.LoadedImageSurface data) + public RxLoadedImageSurfaceEvents(global::Windows.UI.Xaml.Media.LoadedImageSurface data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args)> LoadCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PathFigureEvents + public class RxPathFigureEvents { private readonly global::Windows.UI.Xaml.Media.PathFigure _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PathFigureEvents(global::Windows.UI.Xaml.Media.PathFigure data) + public RxPathFigureEvents(global::Windows.UI.Xaml.Media.PathFigure data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PathSegmentEvents + public class RxPathSegmentEvents { private readonly global::Windows.UI.Xaml.Media.PathSegment _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PathSegmentEvents(global::Windows.UI.Xaml.Media.PathSegment data) + public RxPathSegmentEvents(global::Windows.UI.Xaml.Media.PathSegment data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ProjectionEvents + public class RxProjectionEvents { private readonly global::Windows.UI.Xaml.Media.Projection _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ProjectionEvents(global::Windows.UI.Xaml.Media.Projection data) + public RxProjectionEvents(global::Windows.UI.Xaml.Media.Projection data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TimelineMarkerEvents + public class RxTimelineMarkerEvents { private readonly global::Windows.UI.Xaml.Media.TimelineMarker _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TimelineMarkerEvents(global::Windows.UI.Xaml.Media.TimelineMarker data) + public RxTimelineMarkerEvents(global::Windows.UI.Xaml.Media.TimelineMarker data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class XamlLightEvents + public class RxXamlLightEvents { private readonly global::Windows.UI.Xaml.Media.XamlLight _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public XamlLightEvents(global::Windows.UI.Xaml.Media.XamlLight data) + public RxXamlLightEvents(global::Windows.UI.Xaml.Media.XamlLight data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -24127,323 +22014,301 @@ namespace Windows.UI.Xaml.Media.Animation /// /// A wrapper class which wraps all the events contained within the class. /// - public static ColorKeyFrameEvents Events(this global::Windows.UI.Xaml.Media.Animation.ColorKeyFrame item) => new ColorKeyFrameEvents(item); + public static RxColorKeyFrameEvents Events(this global::Windows.UI.Xaml.Media.Animation.ColorKeyFrame item) => new RxColorKeyFrameEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ConnectedAnimationEvents Events(this global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation item) => new ConnectedAnimationEvents(item); + public static RxConnectedAnimationEvents Events(this global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation item) => new RxConnectedAnimationEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DoubleKeyFrameEvents Events(this global::Windows.UI.Xaml.Media.Animation.DoubleKeyFrame item) => new DoubleKeyFrameEvents(item); + public static RxDoubleKeyFrameEvents Events(this global::Windows.UI.Xaml.Media.Animation.DoubleKeyFrame item) => new RxDoubleKeyFrameEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static EasingFunctionBaseEvents Events(this global::Windows.UI.Xaml.Media.Animation.EasingFunctionBase item) => new EasingFunctionBaseEvents(item); + public static RxEasingFunctionBaseEvents Events(this global::Windows.UI.Xaml.Media.Animation.EasingFunctionBase item) => new RxEasingFunctionBaseEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static KeySplineEvents Events(this global::Windows.UI.Xaml.Media.Animation.KeySpline item) => new KeySplineEvents(item); + public static RxKeySplineEvents Events(this global::Windows.UI.Xaml.Media.Animation.KeySpline item) => new RxKeySplineEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static NavigationTransitionInfoEvents Events(this global::Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo item) => new NavigationTransitionInfoEvents(item); + public static RxNavigationTransitionInfoEvents Events(this global::Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo item) => new RxNavigationTransitionInfoEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ObjectKeyFrameEvents Events(this global::Windows.UI.Xaml.Media.Animation.ObjectKeyFrame item) => new ObjectKeyFrameEvents(item); + public static RxObjectKeyFrameEvents Events(this global::Windows.UI.Xaml.Media.Animation.ObjectKeyFrame item) => new RxObjectKeyFrameEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PointKeyFrameEvents Events(this global::Windows.UI.Xaml.Media.Animation.PointKeyFrame item) => new PointKeyFrameEvents(item); + public static RxPointKeyFrameEvents Events(this global::Windows.UI.Xaml.Media.Animation.PointKeyFrame item) => new RxPointKeyFrameEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TimelineEvents Events(this global::Windows.UI.Xaml.Media.Animation.Timeline item) => new TimelineEvents(item); + public static RxTimelineEvents Events(this global::Windows.UI.Xaml.Media.Animation.Timeline item) => new RxTimelineEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TransitionEvents Events(this global::Windows.UI.Xaml.Media.Animation.Transition item) => new TransitionEvents(item); + public static RxTransitionEvents Events(this global::Windows.UI.Xaml.Media.Animation.Transition item) => new RxTransitionEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ColorKeyFrameEvents + public class RxColorKeyFrameEvents { private readonly global::Windows.UI.Xaml.Media.Animation.ColorKeyFrame _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ColorKeyFrameEvents(global::Windows.UI.Xaml.Media.Animation.ColorKeyFrame data) + public RxColorKeyFrameEvents(global::Windows.UI.Xaml.Media.Animation.ColorKeyFrame data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ConnectedAnimationEvents + public class RxConnectedAnimationEvents { private readonly global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ConnectedAnimationEvents(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation data) + public RxConnectedAnimationEvents(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args)> Completed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DoubleKeyFrameEvents + public class RxDoubleKeyFrameEvents { private readonly global::Windows.UI.Xaml.Media.Animation.DoubleKeyFrame _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DoubleKeyFrameEvents(global::Windows.UI.Xaml.Media.Animation.DoubleKeyFrame data) + public RxDoubleKeyFrameEvents(global::Windows.UI.Xaml.Media.Animation.DoubleKeyFrame data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class EasingFunctionBaseEvents + public class RxEasingFunctionBaseEvents { private readonly global::Windows.UI.Xaml.Media.Animation.EasingFunctionBase _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public EasingFunctionBaseEvents(global::Windows.UI.Xaml.Media.Animation.EasingFunctionBase data) + public RxEasingFunctionBaseEvents(global::Windows.UI.Xaml.Media.Animation.EasingFunctionBase data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class KeySplineEvents + public class RxKeySplineEvents { private readonly global::Windows.UI.Xaml.Media.Animation.KeySpline _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public KeySplineEvents(global::Windows.UI.Xaml.Media.Animation.KeySpline data) + public RxKeySplineEvents(global::Windows.UI.Xaml.Media.Animation.KeySpline data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class NavigationTransitionInfoEvents + public class RxNavigationTransitionInfoEvents { private readonly global::Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public NavigationTransitionInfoEvents(global::Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo data) + public RxNavigationTransitionInfoEvents(global::Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ObjectKeyFrameEvents + public class RxObjectKeyFrameEvents { private readonly global::Windows.UI.Xaml.Media.Animation.ObjectKeyFrame _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ObjectKeyFrameEvents(global::Windows.UI.Xaml.Media.Animation.ObjectKeyFrame data) + public RxObjectKeyFrameEvents(global::Windows.UI.Xaml.Media.Animation.ObjectKeyFrame data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PointKeyFrameEvents + public class RxPointKeyFrameEvents { private readonly global::Windows.UI.Xaml.Media.Animation.PointKeyFrame _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PointKeyFrameEvents(global::Windows.UI.Xaml.Media.Animation.PointKeyFrame data) + public RxPointKeyFrameEvents(global::Windows.UI.Xaml.Media.Animation.PointKeyFrame data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TimelineEvents + public class RxTimelineEvents { private readonly global::Windows.UI.Xaml.Media.Animation.Timeline _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TimelineEvents(global::Windows.UI.Xaml.Media.Animation.Timeline data) + public RxTimelineEvents(global::Windows.UI.Xaml.Media.Animation.Timeline data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TransitionEvents + public class RxTransitionEvents { private readonly global::Windows.UI.Xaml.Media.Animation.Transition _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TransitionEvents(global::Windows.UI.Xaml.Media.Animation.Transition data) + public RxTransitionEvents(global::Windows.UI.Xaml.Media.Animation.Transition data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -24457,95 +22322,85 @@ namespace Windows.UI.Xaml.Media.Imaging /// /// A wrapper class which wraps all the events contained within the class. /// - public static BitmapImageEvents Events(this global::Windows.UI.Xaml.Media.Imaging.BitmapImage item) => new BitmapImageEvents(item); + public static RxBitmapImageEvents Events(this global::Windows.UI.Xaml.Media.Imaging.BitmapImage item) => new RxBitmapImageEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SvgImageSourceEvents Events(this global::Windows.UI.Xaml.Media.Imaging.SvgImageSource item) => new SvgImageSourceEvents(item); + public static RxSvgImageSourceEvents Events(this global::Windows.UI.Xaml.Media.Imaging.SvgImageSource item) => new RxSvgImageSourceEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class BitmapImageEvents + public class RxBitmapImageEvents : global::Windows.UI.Xaml.Media.RxImageSourceEvents { private readonly global::Windows.UI.Xaml.Media.Imaging.BitmapImage _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BitmapImageEvents(global::Windows.UI.Xaml.Media.Imaging.BitmapImage data) + public RxBitmapImageEvents(global::Windows.UI.Xaml.Media.Imaging.BitmapImage data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable DownloadProgress => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ImageFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable ImageOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SvgImageSourceEvents + public class RxSvgImageSourceEvents : global::Windows.UI.Xaml.Media.RxImageSourceEvents { private readonly global::Windows.UI.Xaml.Media.Imaging.SvgImageSource _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SvgImageSourceEvents(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource data) + public RxSvgImageSourceEvents(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource data): base(data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args)> Opened => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args)> OpenFailed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); } } @@ -24559,34 +22414,32 @@ namespace Windows.UI.Xaml.Media.Media3D /// /// A wrapper class which wraps all the events contained within the class. /// - public static Transform3DEvents Events(this global::Windows.UI.Xaml.Media.Media3D.Transform3D item) => new Transform3DEvents(item); + public static RxTransform3DEvents Events(this global::Windows.UI.Xaml.Media.Media3D.Transform3D item) => new RxTransform3DEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class Transform3DEvents + public class RxTransform3DEvents { private readonly global::Windows.UI.Xaml.Media.Media3D.Transform3D _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public Transform3DEvents(global::Windows.UI.Xaml.Media.Media3D.Transform3D data) + public RxTransform3DEvents(global::Windows.UI.Xaml.Media.Media3D.Transform3D data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -24600,34 +22453,32 @@ namespace Windows.UI.Xaml.Navigation /// /// A wrapper class which wraps all the events contained within the class. /// - public static PageStackEntryEvents Events(this global::Windows.UI.Xaml.Navigation.PageStackEntry item) => new PageStackEntryEvents(item); + public static RxPageStackEntryEvents Events(this global::Windows.UI.Xaml.Navigation.PageStackEntry item) => new RxPageStackEntryEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class PageStackEntryEvents + public class RxPageStackEntryEvents { private readonly global::Windows.UI.Xaml.Navigation.PageStackEntry _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PageStackEntryEvents(global::Windows.UI.Xaml.Navigation.PageStackEntry data) + public RxPageStackEntryEvents(global::Windows.UI.Xaml.Navigation.PageStackEntry data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -24641,64 +22492,56 @@ namespace Windows.UI.Xaml.Printing /// /// A wrapper class which wraps all the events contained within the class. /// - public static PrintDocumentEvents Events(this global::Windows.UI.Xaml.Printing.PrintDocument item) => new PrintDocumentEvents(item); + public static RxPrintDocumentEvents Events(this global::Windows.UI.Xaml.Printing.PrintDocument item) => new RxPrintDocumentEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class PrintDocumentEvents + public class RxPrintDocumentEvents { private readonly global::Windows.UI.Xaml.Printing.PrintDocument _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PrintDocumentEvents(global::Windows.UI.Xaml.Printing.PrintDocument data) + public RxPrintDocumentEvents(global::Windows.UI.Xaml.Printing.PrintDocument data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable AddPages => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Printing.AddPagesEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AddPages += x, x => _data.AddPages -= x); + }, x => _data.AddPages += x, x => _data.AddPages -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)> DataContextChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args)>(eventHandler => { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable GetPreviewPage => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Printing.GetPreviewPageEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GetPreviewPage += x, x => _data.GetPreviewPage -= x); + }, x => _data.GetPreviewPage += x, x => _data.GetPreviewPage -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable Paginate => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Printing.PaginateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paginate += x, x => _data.Paginate -= x); + }, x => _data.Paginate += x, x => _data.Paginate -= x); } } @@ -24712,34 +22555,32 @@ namespace Windows.Web.Http.Filters /// /// A wrapper class which wraps all the events contained within the class. /// - public static HttpBaseProtocolFilterEvents Events(this global::Windows.Web.Http.Filters.HttpBaseProtocolFilter item) => new HttpBaseProtocolFilterEvents(item); + public static RxHttpBaseProtocolFilterEvents Events(this global::Windows.Web.Http.Filters.HttpBaseProtocolFilter item) => new RxHttpBaseProtocolFilterEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class HttpBaseProtocolFilterEvents + public class RxHttpBaseProtocolFilterEvents { private readonly global::Windows.Web.Http.Filters.HttpBaseProtocolFilter _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public HttpBaseProtocolFilterEvents(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter data) + public RxHttpBaseProtocolFilterEvents(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args)> ServerCustomValidationRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); } } @@ -24753,194 +22594,160 @@ namespace Windows.Web.UI /// /// A wrapper class which wraps all the events contained within the class. /// - public static IWebViewControlEvents Events(this global::Windows.Web.UI.IWebViewControl item) => new IWebViewControlEvents(item); + public static RxIWebViewControlEvents Events(this global::Windows.Web.UI.IWebViewControl item) => new RxIWebViewControlEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class IWebViewControlEvents + public class RxIWebViewControlEvents { private readonly global::Windows.Web.UI.IWebViewControl _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IWebViewControlEvents(global::Windows.Web.UI.IWebViewControl data) + public RxIWebViewControlEvents(global::Windows.Web.UI.IWebViewControl data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)> ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } } @@ -24954,265 +22761,221 @@ namespace Windows.Web.UI.Interop /// /// A wrapper class which wraps all the events contained within the class. /// - public static WebViewControlEvents Events(this global::Windows.Web.UI.Interop.WebViewControl item) => new WebViewControlEvents(item); + public static RxWebViewControlEvents Events(this global::Windows.Web.UI.Interop.WebViewControl item) => new RxWebViewControlEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static WebViewControlProcessEvents Events(this global::Windows.Web.UI.Interop.WebViewControlProcess item) => new WebViewControlProcessEvents(item); + public static RxWebViewControlProcessEvents Events(this global::Windows.Web.UI.Interop.WebViewControlProcess item) => new RxWebViewControlProcessEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class WebViewControlEvents + public class RxWebViewControlEvents { private readonly global::Windows.Web.UI.Interop.WebViewControl _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WebViewControlEvents(global::Windows.Web.UI.Interop.WebViewControl data) + public RxWebViewControlEvents(global::Windows.Web.UI.Interop.WebViewControl data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args)> AcceleratorKeyPressed => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyPressed += x, x => _data.AcceleratorKeyPressed -= x); + }, x => _data.AcceleratorKeyPressed += x, x => _data.AcceleratorKeyPressed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> ContainsFullScreenElementChanged => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> ContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> DOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)> FrameContentLoading => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)> FrameDOMContentLoaded => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> FrameNavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> FrameNavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, object args)> GotFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, object args)>(eventHandler => { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)> LongRunningScriptDetected => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, object args)> LostFocus => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, object args)>(eventHandler => { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args)> MoveFocusRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MoveFocusRequested += x, x => _data.MoveFocusRequested -= x); + }, x => _data.MoveFocusRequested += x, x => _data.MoveFocusRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)> NavigationCompleted => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)> NavigationStarting => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)> NewWindowRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)> PermissionRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)> ScriptNotify => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, object args)> UnsafeContentWarningDisplaying => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, object args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)> UnsupportedUriSchemeIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)> UnviewableContentIdentified => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)> WebResourceRequested => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args)>(eventHandler => { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class WebViewControlProcessEvents + public class RxWebViewControlProcessEvents { private readonly global::Windows.Web.UI.Interop.WebViewControlProcess _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WebViewControlProcessEvents(global::Windows.Web.UI.Interop.WebViewControlProcess data) + public RxWebViewControlProcessEvents(global::Windows.Web.UI.Interop.WebViewControlProcess data) { _data = data; } /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public global::System.IObservable<(global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args)> ProcessExited => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args)>(eventHandler => { void Handler(global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProcessExited += x, x => _data.ProcessExited -= x); + }, x => _data.ProcessExited += x, x => _data.ProcessExited -= x); } } @@ -25224,15 +22987,13 @@ namespace Windows.ApplicationModel.Chat public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable RcsManagerTransportListChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged += x, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged -= x); + }, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged += x, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged -= x); } } @@ -25244,75 +23005,61 @@ namespace Windows.ApplicationModel.Core public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable CoreApplicationBackgroundActivated => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated += x, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated += x, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable CoreApplicationEnteredBackground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.EnteredBackgroundEventArgs>(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable CoreApplicationExiting => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable CoreApplicationLeavingBackground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.LeavingBackgroundEventArgs>(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable CoreApplicationResuming => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable CoreApplicationSuspending => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.SuspendingEventArgs>(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable CoreApplicationUnhandledErrorDetected => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected += x, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected += x, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected -= x); } } @@ -25324,45 +23071,37 @@ namespace Windows.ApplicationModel.DataTransfer public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable ClipboardContentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable ClipboardHistoryChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.ApplicationModel.DataTransfer.ClipboardHistoryChangedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.DataTransfer.ClipboardHistoryChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable ClipboardHistoryEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable ClipboardRoamingEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged -= x); } } @@ -25374,15 +23113,13 @@ namespace Windows.Foundation.Diagnostics public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable AsyncCausalityTracerTracingStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged += x, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged -= x); + }, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged += x, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged -= x); } } @@ -25394,125 +23131,101 @@ namespace Windows.Gaming.Input public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable ArcadeStickArcadeStickAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.ArcadeStick>(eventHandler => { void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded -= x); + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable ArcadeStickArcadeStickRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.ArcadeStick>(eventHandler => { void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved -= x); + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable FlightStickFlightStickAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.FlightStick>(eventHandler => { void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded -= x); + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable FlightStickFlightStickRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.FlightStick>(eventHandler => { void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved -= x); + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable GamepadGamepadAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.Gamepad>(eventHandler => { void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.Gamepad.GamepadAdded += x, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded -= x); + }, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded += x, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable GamepadGamepadRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.Gamepad>(eventHandler => { void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved += x, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved -= x); + }, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved += x, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable RacingWheelRacingWheelAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RacingWheel>(eventHandler => { void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded -= x); + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable RacingWheelRacingWheelRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RacingWheel>(eventHandler => { void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved -= x); + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable RawGameControllerRawGameControllerAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RawGameController>(eventHandler => { void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded -= x); + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable RawGameControllerRawGameControllerRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.RawGameController>(eventHandler => { void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved -= x); + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable UINavigationControllerUINavigationControllerAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.UINavigationController>(eventHandler => { void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded -= x); + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable UINavigationControllerUINavigationControllerRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Gaming.Input.UINavigationController>(eventHandler => { void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved -= x); + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved -= x); } } @@ -25524,25 +23237,21 @@ namespace Windows.Gaming.UI public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable GameBarIsInputRedirectedChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged += x, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged -= x); + }, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged += x, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable GameBarVisibilityChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.UI.GameBar.VisibilityChanged += x, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged -= x); + }, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged += x, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged -= x); } } @@ -25554,65 +23263,53 @@ namespace Windows.Graphics.Display public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable<(global::Windows.Graphics.Display.DisplayInformation sender, object args)> DisplayInformationDisplayContentsInvalidated => global::System.Reactive.Linq.Observable.FromEvent, (global::Windows.Graphics.Display.DisplayInformation sender, object args)>(eventHandler => { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated -= x); + }, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable DisplayPropertiesColorProfileChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable DisplayPropertiesDisplayContentsInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable DisplayPropertiesLogicalDpiChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable DisplayPropertiesOrientationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable DisplayPropertiesStereoEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged -= x); } } @@ -25624,15 +23321,13 @@ namespace Windows.Graphics.Holographic public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable HolographicSpaceIsAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged += x, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged -= x); + }, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged += x, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged -= x); } } @@ -25644,15 +23339,13 @@ namespace Windows.Media.Core.Preview public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable SoundLevelBrokerSoundLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged += x, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged -= x); + }, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged += x, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged -= x); } } @@ -25664,25 +23357,21 @@ namespace Windows.Media.Devices public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable MediaDeviceDefaultAudioCaptureDeviceChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Devices.DefaultAudioCaptureDeviceChangedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.Media.Devices.DefaultAudioCaptureDeviceChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged -= x); + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable MediaDeviceDefaultAudioRenderDeviceChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Devices.DefaultAudioRenderDeviceChangedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.Media.Devices.DefaultAudioRenderDeviceChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged -= x); + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged -= x); } } @@ -25694,25 +23383,21 @@ namespace Windows.Media.Playback public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable BackgroundMediaPlayerMessageReceivedFromBackground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground -= x); + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable BackgroundMediaPlayerMessageReceivedFromForeground => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground -= x); + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground -= x); } } @@ -25724,15 +23409,13 @@ namespace Windows.Networking.Connectivity public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable NetworkInformationNetworkStatusChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged += x, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged -= x); + }, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged += x, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged -= x); } } @@ -25744,15 +23427,13 @@ namespace Windows.Networking.NetworkOperators public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable ESimManagerServiceInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged += x, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged -= x); + }, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged += x, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged -= x); } } @@ -25764,25 +23445,21 @@ namespace Windows.Networking.Proximity public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable PeerFinderConnectionRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Networking.Proximity.ConnectionRequestedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.Networking.Proximity.ConnectionRequestedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested += x, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested -= x); + }, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested += x, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable PeerFinderTriggeredConnectionStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Networking.Proximity.TriggeredConnectionStateChangedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.Networking.Proximity.TriggeredConnectionStateChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged += x, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged -= x); + }, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged += x, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged -= x); } } @@ -25794,15 +23471,13 @@ namespace Windows.Perception.Spatial public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable SpatialStageFrameOfReferenceCurrentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged += x, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged -= x); + }, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged += x, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged -= x); } } @@ -25814,15 +23489,13 @@ namespace Windows.Phone.System.Power public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable PowerManagerPowerSavingModeChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged += x, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged -= x); + }, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged += x, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged -= x); } } @@ -25834,45 +23507,37 @@ namespace Windows.Phone.UI.Input public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable HardwareButtonsBackPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.BackPressedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.Phone.UI.Input.BackPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable HardwareButtonsCameraHalfPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.CameraEventArgs>(eventHandler => { void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable HardwareButtonsCameraPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.CameraEventArgs>(eventHandler => { void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable HardwareButtonsCameraReleased => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Phone.UI.Input.CameraEventArgs>(eventHandler => { void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased -= x); } } @@ -25884,15 +23549,13 @@ namespace Windows.Security.Authentication.Identity.Provider public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable SecondaryAuthenticationFactorAuthenticationAuthenticationStageChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged += x, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged -= x); + }, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged += x, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged -= x); } } @@ -25904,45 +23567,37 @@ namespace Windows.System public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable MemoryManagerAppMemoryUsageDecreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased -= x); + }, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable MemoryManagerAppMemoryUsageIncreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased -= x); + }, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable MemoryManagerAppMemoryUsageLimitChanging => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.System.AppMemoryUsageLimitChangingEventArgs>(eventHandler => { void Handler(object sender, global::Windows.System.AppMemoryUsageLimitChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging += x, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging -= x); + }, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging += x, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable UserDeviceAssociationUserDeviceAssociationChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.System.UserDeviceAssociationChangedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.System.UserDeviceAssociationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged += x, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged -= x); + }, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged += x, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged -= x); } } @@ -25954,95 +23609,77 @@ namespace Windows.System.Power public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable BackgroundEnergyManagerRecentEnergyUsageIncreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased -= x); + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable BackgroundEnergyManagerRecentEnergyUsageReturnedToLow => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable ForegroundEnergyManagerRecentEnergyUsageIncreased => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased -= x); + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable ForegroundEnergyManagerRecentEnergyUsageReturnedToLow => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable PowerManagerBatteryStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.BatteryStatusChanged += x, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged -= x); + }, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged += x, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable PowerManagerEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged += x, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged -= x); + }, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged += x, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable PowerManagerPowerSupplyStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged += x, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged -= x); + }, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged += x, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable PowerManagerRemainingChargePercentChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged += x, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged -= x); + }, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged += x, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable PowerManagerRemainingDischargeTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged += x, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged -= x); + }, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged += x, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged -= x); } } @@ -26054,35 +23691,29 @@ namespace Windows.System.Profile public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable PlatformDiagnosticsAndUsageDataSettingsCollectionLevelChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged += x, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged -= x); + }, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged += x, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable SystemSetupInfoOutOfBoxExperienceStateChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged += x, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged -= x); + }, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged += x, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable WindowsIntegrityPolicyPolicyChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged += x, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged -= x); + }, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged += x, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged -= x); } } @@ -26094,15 +23725,13 @@ namespace Windows.UI.ViewManagement public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable ProjectionManagerProjectionDisplayAvailableChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged += x, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged -= x); + }, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged += x, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged -= x); } } @@ -26114,85 +23743,119 @@ namespace Windows.UI.WebUI public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable WebUIApplicationActivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs eventArgs) => eventHandler(eventArgs); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Activated += x, x => global::Windows.UI.WebUI.WebUIApplication.Activated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Activated += x, x => global::Windows.UI.WebUI.WebUIApplication.Activated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable WebUIApplicationBackgroundActivated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs eventArgs) => eventHandler(eventArgs); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated += x, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated += x, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable WebUIApplicationEnteredBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.IEnteredBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable WebUIApplicationLeavingBackground => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.ILeavingBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable WebUIApplicationNavigated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.UI.WebUI.IWebUINavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Navigated += x, x => global::Windows.UI.WebUI.WebUIApplication.Navigated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Navigated += x, x => global::Windows.UI.WebUI.WebUIApplication.Navigated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable WebUIApplicationNewWebUIViewCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.WebUI.NewWebUIViewCreatedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.WebUI.NewWebUIViewCreatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated += x, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated += x, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable WebUIApplicationResuming => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Resuming += x, x => global::Windows.UI.WebUI.WebUIApplication.Resuming -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Resuming += x, x => global::Windows.UI.WebUI.WebUIApplication.Resuming -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable WebUIApplicationSuspending => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => { void Handler(object sender, global::Windows.ApplicationModel.ISuspendingEventArgs e) => eventHandler(e); return Handler; - } + }, x => global::Windows.UI.WebUI.WebUIApplication.Suspending += x, x => global::Windows.UI.WebUI.WebUIApplication.Suspending -= x); + } +} - , x => global::Windows.UI.WebUI.WebUIApplication.Suspending += x, x => global::Windows.UI.WebUI.WebUIApplication.Suspending -= x); +namespace Windows.UI.Xaml.Input +{ + /// + /// A class that contains extension methods to wrap events contained within static classes within the namespace. + /// + public static class Events + { + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable AccessKeyManagerIsDisplayModeEnabledChanged => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => + { + void Handler(object sender, object args) => eventHandler(args); + return Handler; + }, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged += x, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerGettingFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.GettingFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerGotFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.FocusManagerGotFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerGotFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerLosingFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.LosingFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public static global::System.IObservable FocusManagerLostFocus => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Input.FocusManagerLostFocusEventArgs>(eventHandler => + { + void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerLostFocusEventArgs e) => eventHandler(e); + return Handler; + }, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus -= x); } } @@ -26204,34 +23867,28 @@ namespace Windows.UI.Xaml.Media public static class Events { /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable CompositionTargetRendered => global::System.Reactive.Linq.Observable.FromEvent, global::Windows.UI.Xaml.Media.RenderedEventArgs>(eventHandler => { void Handler(object sender, global::Windows.UI.Xaml.Media.RenderedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered -= x); + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable CompositionTargetRendering => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering -= x); + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering -= x); /// - /// Gets an observable which signals when the event triggers. + /// Gets an observable which signals when the event triggers. /// public static global::System.IObservable CompositionTargetSurfaceContentsLost => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost -= x); + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.netstandard2.0.approved.txt index ff8c844..45eafdd 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.netstandard2.0.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.netstandard2.0.approved.txt @@ -40,9 +40,7 @@ namespace Uno.UI.Common { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } } @@ -81,9 +79,7 @@ namespace Uno.Xaml { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnNameScopeInitializationComplete += x, x => _data.OnNameScopeInitializationComplete -= x); + }, x => _data.OnNameScopeInitializationComplete += x, x => _data.OnNameScopeInitializationComplete -= x); } } @@ -122,9 +118,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageContentGroupStaging += x, x => _data.PackageContentGroupStaging -= x); + }, x => _data.PackageContentGroupStaging += x, x => _data.PackageContentGroupStaging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -132,9 +126,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageInstalling += x, x => _data.PackageInstalling -= x); + }, x => _data.PackageInstalling += x, x => _data.PackageInstalling -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -142,9 +134,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageStaging += x, x => _data.PackageStaging -= x); + }, x => _data.PackageStaging += x, x => _data.PackageStaging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -152,9 +142,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -162,9 +150,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -172,9 +158,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); } } @@ -213,9 +197,7 @@ namespace Windows.ApplicationModel.Activation { void Handler(global::Windows.ApplicationModel.Activation.SplashScreen sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); } } @@ -254,9 +236,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageInstalled += x, x => _data.PackageInstalled -= x); + }, x => _data.PackageInstalled += x, x => _data.PackageInstalled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -264,9 +244,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -274,9 +252,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -284,9 +260,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUpdated += x, x => _data.PackageUpdated -= x); + }, x => _data.PackageUpdated += x, x => _data.PackageUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -294,9 +268,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); } } @@ -339,9 +311,7 @@ namespace Windows.ApplicationModel.Appointments { void Handler(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } /// @@ -366,9 +336,7 @@ namespace Windows.ApplicationModel.Appointments { void Handler(global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); } } @@ -407,9 +375,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CancelMeetingRequested += x, x => _data.CancelMeetingRequested -= x); + }, x => _data.CancelMeetingRequested += x, x => _data.CancelMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -417,9 +383,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateOrUpdateAppointmentRequested += x, x => _data.CreateOrUpdateAppointmentRequested -= x); + }, x => _data.CreateOrUpdateAppointmentRequested += x, x => _data.CreateOrUpdateAppointmentRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -427,9 +391,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -437,9 +399,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -447,9 +407,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -457,9 +415,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); } } @@ -498,9 +454,7 @@ namespace Windows.ApplicationModel.AppService { void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -508,9 +462,7 @@ namespace Windows.ApplicationModel.AppService { void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServiceClosed += x, x => _data.ServiceClosed -= x); + }, x => _data.ServiceClosed += x, x => _data.ServiceClosed -= x); } } @@ -561,9 +513,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -571,9 +521,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Progress += x, x => _data.Progress -= x); + }, x => _data.Progress += x, x => _data.Progress -= x); } /// @@ -598,9 +546,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BackgroundActivated += x, x => _data.BackgroundActivated -= x); + }, x => _data.BackgroundActivated += x, x => _data.BackgroundActivated -= x); } /// @@ -625,9 +571,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); } /// @@ -652,9 +596,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -662,9 +604,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Progress += x, x => _data.Progress -= x); + }, x => _data.Progress += x, x => _data.Progress -= x); } } @@ -715,9 +655,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteParticipantComposingChanged += x, x => _data.RemoteParticipantComposingChanged -= x); + }, x => _data.RemoteParticipantComposingChanged += x, x => _data.RemoteParticipantComposingChanged -= x); } /// @@ -742,9 +680,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageChanged += x, x => _data.MessageChanged -= x); + }, x => _data.MessageChanged += x, x => _data.MessageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -752,9 +688,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); } /// @@ -779,9 +713,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageAvailableChanged += x, x => _data.MessageAvailableChanged -= x); + }, x => _data.MessageAvailableChanged += x, x => _data.MessageAvailableChanged -= x); } /// @@ -806,9 +738,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServiceKindSupportedChanged += x, x => _data.ServiceKindSupportedChanged -= x); + }, x => _data.ServiceKindSupportedChanged += x, x => _data.ServiceKindSupportedChanged -= x); } } @@ -859,9 +789,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); } /// @@ -886,9 +814,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } /// @@ -913,9 +839,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -923,9 +847,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LaunchFullAppRequested += x, x => _data.LaunchFullAppRequested -= x); + }, x => _data.LaunchFullAppRequested += x, x => _data.LaunchFullAppRequested -= x); } /// @@ -950,9 +872,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); } } @@ -991,9 +911,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateOrUpdateContactRequested += x, x => _data.CreateOrUpdateContactRequested -= x); + }, x => _data.CreateOrUpdateContactRequested += x, x => _data.CreateOrUpdateContactRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1001,9 +919,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeleteContactRequested += x, x => _data.DeleteContactRequested -= x); + }, x => _data.DeleteContactRequested += x, x => _data.DeleteContactRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1011,9 +927,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1021,9 +935,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); } } @@ -1062,9 +974,7 @@ namespace Windows.ApplicationModel.Contacts.Provider { void Handler(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContactRemoved += x, x => _data.ContactRemoved -= x); + }, x => _data.ContactRemoved += x, x => _data.ContactRemoved -= x); } } @@ -1111,9 +1021,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1121,9 +1029,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HostedViewClosing += x, x => _data.HostedViewClosing -= x); + }, x => _data.HostedViewClosing += x, x => _data.HostedViewClosing -= x); } /// @@ -1148,9 +1054,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1158,9 +1062,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LayoutMetricsChanged += x, x => _data.LayoutMetricsChanged -= x); + }, x => _data.LayoutMetricsChanged += x, x => _data.LayoutMetricsChanged -= x); } /// @@ -1185,9 +1087,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UnhandledErrorDetected += x, x => _data.UnhandledErrorDetected -= x); + }, x => _data.UnhandledErrorDetected += x, x => _data.UnhandledErrorDetected -= x); } } @@ -1230,9 +1130,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1240,9 +1138,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1250,9 +1146,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShareCompleted += x, x => _data.ShareCompleted -= x); + }, x => _data.ShareCompleted += x, x => _data.ShareCompleted -= x); } /// @@ -1277,9 +1171,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataRequested += x, x => _data.DataRequested -= x); + }, x => _data.DataRequested += x, x => _data.DataRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1287,9 +1179,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShareProvidersRequested += x, x => _data.ShareProvidersRequested -= x); + }, x => _data.ShareProvidersRequested += x, x => _data.ShareProvidersRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1297,9 +1187,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetApplicationChosen += x, x => _data.TargetApplicationChosen -= x); + }, x => _data.TargetApplicationChosen += x, x => _data.TargetApplicationChosen -= x); } } @@ -1338,9 +1226,7 @@ namespace Windows.ApplicationModel.DataTransfer.DragDrop.Core { void Handler(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetRequested += x, x => _data.TargetRequested -= x); + }, x => _data.TargetRequested += x, x => _data.TargetRequested -= x); } } @@ -1383,9 +1269,7 @@ namespace Windows.ApplicationModel.Email { void Handler(global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MailboxChanged += x, x => _data.MailboxChanged -= x); + }, x => _data.MailboxChanged += x, x => _data.MailboxChanged -= x); } /// @@ -1410,9 +1294,7 @@ namespace Windows.ApplicationModel.Email { void Handler(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } } @@ -1451,9 +1333,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateFolderRequested += x, x => _data.CreateFolderRequested -= x); + }, x => _data.CreateFolderRequested += x, x => _data.CreateFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1461,9 +1341,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeleteFolderRequested += x, x => _data.DeleteFolderRequested -= x); + }, x => _data.DeleteFolderRequested += x, x => _data.DeleteFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1471,9 +1349,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadAttachmentRequested += x, x => _data.DownloadAttachmentRequested -= x); + }, x => _data.DownloadAttachmentRequested += x, x => _data.DownloadAttachmentRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1481,9 +1357,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadMessageRequested += x, x => _data.DownloadMessageRequested -= x); + }, x => _data.DownloadMessageRequested += x, x => _data.DownloadMessageRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1491,9 +1365,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EmptyFolderRequested += x, x => _data.EmptyFolderRequested -= x); + }, x => _data.EmptyFolderRequested += x, x => _data.EmptyFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1501,9 +1373,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1511,9 +1381,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GetAutoReplySettingsRequested += x, x => _data.GetAutoReplySettingsRequested -= x); + }, x => _data.GetAutoReplySettingsRequested += x, x => _data.GetAutoReplySettingsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1521,9 +1389,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MailboxSyncRequested += x, x => _data.MailboxSyncRequested -= x); + }, x => _data.MailboxSyncRequested += x, x => _data.MailboxSyncRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1531,9 +1397,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MoveFolderRequested += x, x => _data.MoveFolderRequested -= x); + }, x => _data.MoveFolderRequested += x, x => _data.MoveFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1541,9 +1405,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1551,9 +1413,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResolveRecipientsRequested += x, x => _data.ResolveRecipientsRequested -= x); + }, x => _data.ResolveRecipientsRequested += x, x => _data.ResolveRecipientsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1561,9 +1421,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1571,9 +1429,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetAutoReplySettingsRequested += x, x => _data.SetAutoReplySettingsRequested -= x); + }, x => _data.SetAutoReplySettingsRequested += x, x => _data.SetAutoReplySettingsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1581,9 +1437,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1591,9 +1445,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValidateCertificatesRequested += x, x => _data.ValidateCertificatesRequested -= x); + }, x => _data.ValidateCertificatesRequested += x, x => _data.ValidateCertificatesRequested -= x); } } @@ -1632,9 +1484,7 @@ namespace Windows.ApplicationModel.ExtendedExecution { void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionRevokedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Revoked += x, x => _data.Revoked -= x); + }, x => _data.Revoked += x, x => _data.Revoked -= x); } } @@ -1673,9 +1523,7 @@ namespace Windows.ApplicationModel.ExtendedExecution.Foreground { void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundRevokedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Revoked += x, x => _data.Revoked -= x); + }, x => _data.Revoked += x, x => _data.Revoked -= x); } } @@ -1718,9 +1566,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Unlocking += x, x => _data.Unlocking -= x); + }, x => _data.Unlocking += x, x => _data.Unlocking -= x); } /// @@ -1745,9 +1591,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AlarmIconChanged += x, x => _data.AlarmIconChanged -= x); + }, x => _data.AlarmIconChanged += x, x => _data.AlarmIconChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1755,9 +1599,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BadgesChanged += x, x => _data.BadgesChanged -= x); + }, x => _data.BadgesChanged += x, x => _data.BadgesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1765,9 +1607,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DetailTextChanged += x, x => _data.DetailTextChanged -= x); + }, x => _data.DetailTextChanged += x, x => _data.DetailTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1775,9 +1615,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LockScreenImageChanged += x, x => _data.LockScreenImageChanged -= x); + }, x => _data.LockScreenImageChanged += x, x => _data.LockScreenImageChanged -= x); } } @@ -1816,9 +1654,7 @@ namespace Windows.ApplicationModel.Resources.Core { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } } @@ -1857,9 +1693,7 @@ namespace Windows.ApplicationModel.Store { void Handler() => eventHandler(global::System.Reactive.Unit.Default); return Handler; - } - - , x => _data.LicenseChanged += x, x => _data.LicenseChanged -= x); + }, x => _data.LicenseChanged += x, x => _data.LicenseChanged -= x); } } @@ -1902,9 +1736,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1912,9 +1744,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -1939,9 +1769,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemCompleted += x, x => _data.ItemCompleted -= x); + }, x => _data.ItemCompleted += x, x => _data.ItemCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1949,9 +1777,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemStatusChanged += x, x => _data.ItemStatusChanged -= x); + }, x => _data.ItemStatusChanged += x, x => _data.ItemStatusChanged -= x); } } @@ -1990,9 +1816,7 @@ namespace Windows.ApplicationModel.UserActivities { void Handler(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserActivityRequested += x, x => _data.UserActivityRequested -= x); + }, x => _data.UserActivityRequested += x, x => _data.UserActivityRequested -= x); } } @@ -2031,9 +1855,7 @@ namespace Windows.ApplicationModel.UserDataAccounts { void Handler(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); } } @@ -2072,9 +1894,7 @@ namespace Windows.ApplicationModel.UserDataTasks { void Handler(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } } @@ -2113,9 +1933,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompleteTaskRequested += x, x => _data.CompleteTaskRequested -= x); + }, x => _data.CompleteTaskRequested += x, x => _data.CompleteTaskRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2123,9 +1941,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateOrUpdateTaskRequested += x, x => _data.CreateOrUpdateTaskRequested -= x); + }, x => _data.CreateOrUpdateTaskRequested += x, x => _data.CreateOrUpdateTaskRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2133,9 +1949,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeleteTaskRequested += x, x => _data.DeleteTaskRequested -= x); + }, x => _data.DeleteTaskRequested += x, x => _data.DeleteTaskRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2143,9 +1957,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SkipOccurrenceRequested += x, x => _data.SkipOccurrenceRequested -= x); + }, x => _data.SkipOccurrenceRequested += x, x => _data.SkipOccurrenceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2153,9 +1965,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); } } @@ -2194,9 +2004,7 @@ namespace Windows.ApplicationModel.VoiceCommands { void Handler(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VoiceCommandCompleted += x, x => _data.VoiceCommandCompleted -= x); + }, x => _data.VoiceCommandCompleted += x, x => _data.VoiceCommandCompleted -= x); } } @@ -2235,9 +2043,7 @@ namespace Windows.ApplicationModel.Wallet.System { void Handler(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); } } @@ -2284,9 +2090,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceptSessionJoinerRequested += x, x => _data.AcceptSessionJoinerRequested -= x); + }, x => _data.AcceptSessionJoinerRequested += x, x => _data.AcceptSessionJoinerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2294,9 +2098,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AuthenticationComplete += x, x => _data.AuthenticationComplete -= x); + }, x => _data.AuthenticationComplete += x, x => _data.AuthenticationComplete -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2304,9 +2106,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CredentialsRequested += x, x => _data.CredentialsRequested -= x); + }, x => _data.CredentialsRequested += x, x => _data.CredentialsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2314,9 +2114,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CredentialsVerificationRequested += x, x => _data.CredentialsVerificationRequested -= x); + }, x => _data.CredentialsVerificationRequested += x, x => _data.CredentialsVerificationRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2324,9 +2122,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionJoined += x, x => _data.SessionJoined -= x); + }, x => _data.SessionJoined += x, x => _data.SessionJoined -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2334,9 +2130,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -2361,9 +2155,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -2388,9 +2180,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Lost += x, x => _data.Lost -= x); + }, x => _data.Lost += x, x => _data.Lost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2398,9 +2188,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MemberAdded += x, x => _data.MemberAdded -= x); + }, x => _data.MemberAdded += x, x => _data.MemberAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2408,9 +2196,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MemberRemoved += x, x => _data.MemberRemoved -= x); + }, x => _data.MemberRemoved += x, x => _data.MemberRemoved -= x); } } @@ -2453,9 +2239,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2463,9 +2247,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NameChanged += x, x => _data.NameChanged -= x); + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2473,9 +2255,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SdpRecordsChanged += x, x => _data.SdpRecordsChanged -= x); + }, x => _data.SdpRecordsChanged += x, x => _data.SdpRecordsChanged -= x); } /// @@ -2500,9 +2280,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2510,9 +2288,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GattServicesChanged += x, x => _data.GattServicesChanged -= x); + }, x => _data.GattServicesChanged += x, x => _data.GattServicesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2520,9 +2296,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NameChanged += x, x => _data.NameChanged -= x); + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); } } @@ -2565,9 +2339,7 @@ namespace Windows.Devices.Bluetooth.Advertisement { void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -2592,9 +2364,7 @@ namespace Windows.Devices.Bluetooth.Advertisement { void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Received += x, x => _data.Received -= x); + }, x => _data.Received += x, x => _data.Received -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2602,9 +2372,7 @@ namespace Windows.Devices.Bluetooth.Advertisement { void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -2671,9 +2439,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2698,9 +2464,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2708,9 +2472,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SubscribedClientsChanged += x, x => _data.SubscribedClientsChanged -= x); + }, x => _data.SubscribedClientsChanged += x, x => _data.SubscribedClientsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2718,9 +2480,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); } /// @@ -2745,9 +2505,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2755,9 +2513,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); } /// @@ -2782,9 +2538,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -2809,9 +2563,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); } /// @@ -2836,9 +2588,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MaxPduSizeChanged += x, x => _data.MaxPduSizeChanged -= x); + }, x => _data.MaxPduSizeChanged += x, x => _data.MaxPduSizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2846,9 +2596,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); } /// @@ -2873,9 +2621,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MaxNotificationSizeChanged += x, x => _data.MaxNotificationSizeChanged -= x); + }, x => _data.MaxNotificationSizeChanged += x, x => _data.MaxNotificationSizeChanged -= x); } /// @@ -2900,9 +2646,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -2941,9 +2685,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2951,9 +2693,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Disabled += x, x => _data.Disabled -= x); + }, x => _data.Disabled += x, x => _data.Disabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2961,9 +2701,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Enabled += x, x => _data.Enabled -= x); + }, x => _data.Enabled += x, x => _data.Enabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2971,9 +2709,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PathsFailedOrInvalidated += x, x => _data.PathsFailedOrInvalidated -= x); + }, x => _data.PathsFailedOrInvalidated += x, x => _data.PathsFailedOrInvalidated -= x); } } @@ -3024,9 +2760,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessChanged += x, x => _data.AccessChanged -= x); + }, x => _data.AccessChanged += x, x => _data.AccessChanged -= x); } /// @@ -3051,9 +2785,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PairingRequested += x, x => _data.PairingRequested -= x); + }, x => _data.PairingRequested += x, x => _data.PairingRequested -= x); } /// @@ -3078,9 +2810,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DevicePickerDismissed += x, x => _data.DevicePickerDismissed -= x); + }, x => _data.DevicePickerDismissed += x, x => _data.DevicePickerDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3088,9 +2818,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeviceSelected += x, x => _data.DeviceSelected -= x); + }, x => _data.DeviceSelected += x, x => _data.DeviceSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3098,9 +2826,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); } /// @@ -3125,9 +2851,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3135,9 +2859,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3145,9 +2867,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3155,9 +2875,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3165,9 +2883,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -3206,9 +2922,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3216,9 +2930,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3226,9 +2938,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3236,9 +2946,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3246,9 +2954,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -3291,9 +2997,7 @@ namespace Windows.Devices.Geolocation { void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3301,9 +3005,7 @@ namespace Windows.Devices.Geolocation { void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -3328,9 +3030,7 @@ namespace Windows.Devices.Geolocation { void Handler(global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisitStateChanged += x, x => _data.VisitStateChanged -= x); + }, x => _data.VisitStateChanged += x, x => _data.VisitStateChanged -= x); } } @@ -3369,9 +3069,7 @@ namespace Windows.Devices.Geolocation.Geofencing { void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GeofenceStateChanged += x, x => _data.GeofenceStateChanged -= x); + }, x => _data.GeofenceStateChanged += x, x => _data.GeofenceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3379,9 +3077,7 @@ namespace Windows.Devices.Geolocation.Geofencing { void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } } @@ -3420,9 +3116,7 @@ namespace Windows.Devices.HumanInterfaceDevice { void Handler(global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputReportReceived += x, x => _data.InputReportReceived -= x); + }, x => _data.InputReportReceived += x, x => _data.InputReportReceived -= x); } } @@ -3461,9 +3155,7 @@ namespace Windows.Devices.Input { void Handler(global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MouseMoved += x, x => _data.MouseMoved -= x); + }, x => _data.MouseMoved += x, x => _data.MouseMoved -= x); } } @@ -3506,9 +3198,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3516,9 +3206,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3526,9 +3214,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3536,9 +3222,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -3563,9 +3247,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GazeEntered += x, x => _data.GazeEntered -= x); + }, x => _data.GazeEntered += x, x => _data.GazeEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3573,9 +3255,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GazeExited += x, x => _data.GazeExited -= x); + }, x => _data.GazeExited += x, x => _data.GazeExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3583,9 +3263,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GazeMoved += x, x => _data.GazeMoved -= x); + }, x => _data.GazeMoved += x, x => _data.GazeMoved -= x); } } @@ -3624,9 +3302,7 @@ namespace Windows.Devices.Lights { void Handler(global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); + }, x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); } } @@ -3669,9 +3345,7 @@ namespace Windows.Devices.Lights.Effects { void Handler(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); } /// @@ -3696,9 +3370,7 @@ namespace Windows.Devices.Lights.Effects { void Handler(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateRequested += x, x => _data.UpdateRequested -= x); + }, x => _data.UpdateRequested += x, x => _data.UpdateRequested -= x); } } @@ -3737,9 +3409,7 @@ namespace Windows.Devices.Midi { void Handler(global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } } @@ -3814,9 +3484,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -3841,9 +3509,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3851,9 +3517,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3861,9 +3525,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3871,9 +3533,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3881,9 +3541,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); } /// @@ -3908,9 +3566,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3918,9 +3574,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3928,9 +3582,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3938,9 +3590,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -3965,9 +3615,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionControlSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ControlLost += x, x => _data.ControlLost -= x); + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); } /// @@ -3992,9 +3640,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -4019,9 +3665,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4029,9 +3673,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4039,9 +3681,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4049,9 +3689,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4059,9 +3697,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); } /// @@ -4086,9 +3722,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4096,9 +3730,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4106,9 +3738,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4116,9 +3746,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -4143,9 +3771,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -4170,9 +3796,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4180,9 +3804,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4190,9 +3812,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4200,9 +3820,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4210,9 +3828,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); } /// @@ -4237,9 +3853,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4247,9 +3861,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4257,9 +3869,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4267,9 +3877,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -4348,9 +3956,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -4375,9 +3981,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -4402,9 +4006,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AlarmTimeoutExpired += x, x => _data.AlarmTimeoutExpired -= x); + }, x => _data.AlarmTimeoutExpired += x, x => _data.AlarmTimeoutExpired -= x); } /// @@ -4429,9 +4031,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); + }, x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4439,9 +4039,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); + }, x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); } /// @@ -4466,9 +4064,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4476,9 +4072,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4486,9 +4080,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4496,9 +4088,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ImagePreviewReceived += x, x => _data.ImagePreviewReceived -= x); + }, x => _data.ImagePreviewReceived += x, x => _data.ImagePreviewReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4506,9 +4096,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4516,9 +4104,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); return Handler; - } - - , x => _data.TriggerPressed += x, x => _data.TriggerPressed -= x); + }, x => _data.TriggerPressed += x, x => _data.TriggerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4526,9 +4112,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); return Handler; - } - - , x => _data.TriggerReleased += x, x => _data.TriggerReleased -= x); + }, x => _data.TriggerReleased += x, x => _data.TriggerReleased -= x); } /// @@ -4553,9 +4137,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4563,9 +4145,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); } /// @@ -4590,9 +4170,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4600,9 +4178,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4610,9 +4186,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -4637,9 +4211,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AamvaCardDataReceived += x, x => _data.AamvaCardDataReceived -= x); + }, x => _data.AamvaCardDataReceived += x, x => _data.AamvaCardDataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4647,9 +4219,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BankCardDataReceived += x, x => _data.BankCardDataReceived -= x); + }, x => _data.BankCardDataReceived += x, x => _data.BankCardDataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4657,9 +4227,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4667,9 +4235,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4677,9 +4243,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader e) => eventHandler(e); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4687,9 +4251,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VendorSpecificDataReceived += x, x => _data.VendorSpecificDataReceived -= x); + }, x => _data.VendorSpecificDataReceived += x, x => _data.VendorSpecificDataReceived -= x); } /// @@ -4714,9 +4276,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4724,9 +4284,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); } /// @@ -4751,9 +4309,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -4778,9 +4334,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } } @@ -4823,9 +4377,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -4850,9 +4402,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisableScannerRequested += x, x => _data.DisableScannerRequested -= x); + }, x => _data.DisableScannerRequested += x, x => _data.DisableScannerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4860,9 +4410,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnableScannerRequested += x, x => _data.EnableScannerRequested -= x); + }, x => _data.EnableScannerRequested += x, x => _data.EnableScannerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4870,9 +4418,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GetBarcodeSymbologyAttributesRequested += x, x => _data.GetBarcodeSymbologyAttributesRequested -= x); + }, x => _data.GetBarcodeSymbologyAttributesRequested += x, x => _data.GetBarcodeSymbologyAttributesRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4880,9 +4426,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HideVideoPreviewRequested += x, x => _data.HideVideoPreviewRequested -= x); + }, x => _data.HideVideoPreviewRequested += x, x => _data.HideVideoPreviewRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4890,9 +4434,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetActiveSymbologiesRequested += x, x => _data.SetActiveSymbologiesRequested -= x); + }, x => _data.SetActiveSymbologiesRequested += x, x => _data.SetActiveSymbologiesRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4900,9 +4442,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetBarcodeSymbologyAttributesRequested += x, x => _data.SetBarcodeSymbologyAttributesRequested -= x); + }, x => _data.SetBarcodeSymbologyAttributesRequested += x, x => _data.SetBarcodeSymbologyAttributesRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4910,9 +4450,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StartSoftwareTriggerRequested += x, x => _data.StartSoftwareTriggerRequested -= x); + }, x => _data.StartSoftwareTriggerRequested += x, x => _data.StartSoftwareTriggerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4920,9 +4458,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StopSoftwareTriggerRequested += x, x => _data.StopSoftwareTriggerRequested -= x); + }, x => _data.StopSoftwareTriggerRequested += x, x => _data.StopSoftwareTriggerRequested -= x); } } @@ -4961,9 +4497,7 @@ namespace Windows.Devices.Power { void Handler(global::Windows.Devices.Power.Battery sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReportUpdated += x, x => _data.ReportUpdated -= x); + }, x => _data.ReportUpdated += x, x => _data.ReportUpdated -= x); } } @@ -5002,9 +4536,7 @@ namespace Windows.Devices.Printers.Extensions { void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrinterChanged += x, x => _data.PrinterChanged -= x); + }, x => _data.PrinterChanged += x, x => _data.PrinterChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5012,9 +4544,7 @@ namespace Windows.Devices.Printers.Extensions { void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrintRequested += x, x => _data.PrintRequested -= x); + }, x => _data.PrintRequested += x, x => _data.PrintRequested -= x); } } @@ -5053,9 +4583,7 @@ namespace Windows.Devices.Radios { void Handler(global::Windows.Devices.Radios.Radio sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -5146,9 +4674,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5156,9 +4682,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Shaken += x, x => _data.Shaken -= x); + }, x => _data.Shaken += x, x => _data.Shaken -= x); } /// @@ -5183,9 +4707,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -5210,9 +4732,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -5237,9 +4757,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -5264,9 +4782,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -5291,9 +4807,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -5318,9 +4832,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -5345,9 +4857,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -5372,9 +4882,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -5399,9 +4907,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -5426,9 +4932,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -5453,9 +4957,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -5480,9 +4982,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -5507,9 +5007,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); } } @@ -5548,9 +5046,7 @@ namespace Windows.Devices.Sensors.Custom { void Handler(global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } } @@ -5589,9 +5085,7 @@ namespace Windows.Devices.SerialCommunication { void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorReceived += x, x => _data.ErrorReceived -= x); + }, x => _data.ErrorReceived += x, x => _data.ErrorReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5599,9 +5093,7 @@ namespace Windows.Devices.SerialCommunication { void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PinChanged += x, x => _data.PinChanged -= x); + }, x => _data.PinChanged += x, x => _data.PinChanged -= x); } } @@ -5640,9 +5132,7 @@ namespace Windows.Devices.SmartCards { void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CardAdded += x, x => _data.CardAdded -= x); + }, x => _data.CardAdded += x, x => _data.CardAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5650,9 +5140,7 @@ namespace Windows.Devices.SmartCards { void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CardRemoved += x, x => _data.CardRemoved -= x); + }, x => _data.CardRemoved += x, x => _data.CardRemoved -= x); } } @@ -5695,9 +5183,7 @@ namespace Windows.Devices.Sms { void Handler(global::Windows.Devices.Sms.SmsDevice2 sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeviceStatusChanged += x, x => _data.DeviceStatusChanged -= x); + }, x => _data.DeviceStatusChanged += x, x => _data.DeviceStatusChanged -= x); } /// @@ -5722,9 +5208,7 @@ namespace Windows.Devices.Sms { void Handler(global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } } @@ -5763,9 +5247,7 @@ namespace Windows.Devices.Usb { void Handler(global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); } } @@ -5804,9 +5286,7 @@ namespace Windows.Devices.WiFi { void Handler(global::Windows.Devices.WiFi.WiFiAdapter sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableNetworksChanged += x, x => _data.AvailableNetworksChanged -= x); + }, x => _data.AvailableNetworksChanged += x, x => _data.AvailableNetworksChanged -= x); } } @@ -5853,9 +5333,7 @@ namespace Windows.Devices.WiFiDirect { void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -5880,9 +5358,7 @@ namespace Windows.Devices.WiFiDirect { void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); + }, x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); } /// @@ -5907,9 +5383,7 @@ namespace Windows.Devices.WiFiDirect { void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); } } @@ -5956,9 +5430,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionDeferred += x, x => _data.SessionDeferred -= x); + }, x => _data.SessionDeferred += x, x => _data.SessionDeferred -= x); } /// @@ -5983,9 +5455,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5993,9 +5463,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutoAcceptSessionConnected += x, x => _data.AutoAcceptSessionConnected -= x); + }, x => _data.AutoAcceptSessionConnected += x, x => _data.AutoAcceptSessionConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6003,9 +5471,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionRequested += x, x => _data.SessionRequested -= x); + }, x => _data.SessionRequested += x, x => _data.SessionRequested -= x); } /// @@ -6030,9 +5496,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemotePortAdded += x, x => _data.RemotePortAdded -= x); + }, x => _data.RemotePortAdded += x, x => _data.RemotePortAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6040,9 +5504,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); } } @@ -6081,9 +5543,7 @@ namespace Windows.Foundation { void Handler(global::Windows.Foundation.IMemoryBufferReference sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } } @@ -6130,9 +5590,7 @@ namespace Windows.Foundation.Collections { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -6157,9 +5615,7 @@ namespace Windows.Foundation.Collections { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -6184,9 +5640,7 @@ namespace Windows.Foundation.Collections { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } } @@ -6237,9 +5691,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); } /// @@ -6264,9 +5716,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); } /// @@ -6291,9 +5741,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); } /// @@ -6318,9 +5766,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); } } @@ -6383,9 +5829,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6393,9 +5837,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6403,9 +5845,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -6430,9 +5870,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6440,9 +5878,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6450,9 +5886,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -6477,9 +5911,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6487,9 +5919,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6497,9 +5927,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -6524,9 +5952,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6534,9 +5960,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6544,9 +5968,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -6571,9 +5993,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6581,9 +6001,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6591,9 +6009,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -6618,9 +6034,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6628,9 +6042,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6638,9 +6050,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -6665,9 +6075,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6675,9 +6083,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6685,9 +6091,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } } @@ -6730,9 +6134,7 @@ namespace Windows.Graphics.Capture { void Handler(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -6757,9 +6159,7 @@ namespace Windows.Graphics.Capture { void Handler(global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } } @@ -6806,9 +6206,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BrightnessLevelChanged += x, x => _data.BrightnessLevelChanged -= x); + }, x => _data.BrightnessLevelChanged += x, x => _data.BrightnessLevelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6816,9 +6214,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6826,9 +6222,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); + }, x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); } /// @@ -6853,9 +6247,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CanOverrideChanged += x, x => _data.CanOverrideChanged -= x); + }, x => _data.CanOverrideChanged += x, x => _data.CanOverrideChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6863,9 +6255,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisplayEnhancementOverrideCapabilitiesChanged += x, x => _data.DisplayEnhancementOverrideCapabilitiesChanged -= x); + }, x => _data.DisplayEnhancementOverrideCapabilitiesChanged += x, x => _data.DisplayEnhancementOverrideCapabilitiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6873,9 +6263,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); } /// @@ -6900,9 +6288,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvancedColorInfoChanged += x, x => _data.AdvancedColorInfoChanged -= x); + }, x => _data.AdvancedColorInfoChanged += x, x => _data.AdvancedColorInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6910,9 +6296,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorProfileChanged += x, x => _data.ColorProfileChanged -= x); + }, x => _data.ColorProfileChanged += x, x => _data.ColorProfileChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6920,9 +6304,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6930,9 +6312,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6940,9 +6320,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StereoEnabledChanged += x, x => _data.StereoEnabledChanged -= x); + }, x => _data.StereoEnabledChanged += x, x => _data.StereoEnabledChanged -= x); } } @@ -6981,9 +6359,7 @@ namespace Windows.Graphics.Display.Core { void Handler(global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisplayModesChanged += x, x => _data.DisplayModesChanged -= x); + }, x => _data.DisplayModesChanged += x, x => _data.DisplayModesChanged -= x); } } @@ -7022,9 +6398,7 @@ namespace Windows.Graphics.Holographic { void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraAdded += x, x => _data.CameraAdded -= x); + }, x => _data.CameraAdded += x, x => _data.CameraAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7032,9 +6406,7 @@ namespace Windows.Graphics.Holographic { void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraRemoved += x, x => _data.CameraRemoved -= x); + }, x => _data.CameraRemoved += x, x => _data.CameraRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7042,9 +6414,7 @@ namespace Windows.Graphics.Holographic { void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserPresenceChanged += x, x => _data.UserPresenceChanged -= x); + }, x => _data.UserPresenceChanged += x, x => _data.UserPresenceChanged -= x); } } @@ -7087,9 +6457,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrintTaskRequested += x, x => _data.PrintTaskRequested -= x); + }, x => _data.PrintTaskRequested += x, x => _data.PrintTaskRequested -= x); } /// @@ -7114,9 +6482,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7124,9 +6490,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Previewing += x, x => _data.Previewing -= x); + }, x => _data.Previewing += x, x => _data.Previewing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7134,9 +6498,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Progressing += x, x => _data.Progressing -= x); + }, x => _data.Progressing += x, x => _data.Progressing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7144,9 +6506,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Submitting += x, x => _data.Submitting -= x); + }, x => _data.Submitting += x, x => _data.Submitting -= x); } } @@ -7185,9 +6545,7 @@ namespace Windows.Graphics.Printing.OptionDetails { void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BeginValidation += x, x => _data.BeginValidation -= x); + }, x => _data.BeginValidation += x, x => _data.BeginValidation -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7195,9 +6553,7 @@ namespace Windows.Graphics.Printing.OptionDetails { void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionChanged += x, x => _data.OptionChanged -= x); + }, x => _data.OptionChanged += x, x => _data.OptionChanged -= x); } } @@ -7240,9 +6596,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7250,9 +6604,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Submitted += x, x => _data.Submitted -= x); + }, x => _data.Submitted += x, x => _data.Submitted -= x); } /// @@ -7277,9 +6629,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7287,9 +6637,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.XpsDataAvailable += x, x => _data.XpsDataAvailable -= x); + }, x => _data.XpsDataAvailable += x, x => _data.XpsDataAvailable -= x); } } @@ -7328,9 +6676,7 @@ namespace Windows.Management.Policies { void Handler(global::Windows.Management.Policies.NamedPolicyData sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } } @@ -7373,9 +6719,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Ended += x, x => _data.Ended -= x); + }, x => _data.Ended += x, x => _data.Ended -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7383,9 +6727,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Failed += x, x => _data.Failed -= x); + }, x => _data.Failed += x, x => _data.Failed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7393,9 +6735,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7403,9 +6743,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -7430,9 +6768,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutoRepeatModeChangeRequested += x, x => _data.AutoRepeatModeChangeRequested -= x); + }, x => _data.AutoRepeatModeChangeRequested += x, x => _data.AutoRepeatModeChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7440,9 +6776,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7450,9 +6784,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackPositionChangeRequested += x, x => _data.PlaybackPositionChangeRequested -= x); + }, x => _data.PlaybackPositionChangeRequested += x, x => _data.PlaybackPositionChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7460,9 +6792,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7470,9 +6800,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7480,9 +6808,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShuffleEnabledChangeRequested += x, x => _data.ShuffleEnabledChangeRequested -= x); + }, x => _data.ShuffleEnabledChangeRequested += x, x => _data.ShuffleEnabledChangeRequested -= x); } } @@ -7541,9 +6867,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioFileInputNode sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileCompleted += x, x => _data.FileCompleted -= x); + }, x => _data.FileCompleted += x, x => _data.FileCompleted -= x); } /// @@ -7568,9 +6892,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioFrameCompleted += x, x => _data.AudioFrameCompleted -= x); + }, x => _data.AudioFrameCompleted += x, x => _data.AudioFrameCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7578,9 +6900,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); } /// @@ -7605,9 +6925,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuantumProcessed += x, x => _data.QuantumProcessed -= x); + }, x => _data.QuantumProcessed += x, x => _data.QuantumProcessed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7615,9 +6933,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7625,9 +6941,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnrecoverableErrorOccurred += x, x => _data.UnrecoverableErrorOccurred -= x); + }, x => _data.UnrecoverableErrorOccurred += x, x => _data.UnrecoverableErrorOccurred -= x); } /// @@ -7652,9 +6966,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioStateMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SoundLevelChanged += x, x => _data.SoundLevelChanged -= x); + }, x => _data.SoundLevelChanged += x, x => _data.SoundLevelChanged -= x); } /// @@ -7679,9 +6991,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaSourceCompleted += x, x => _data.MediaSourceCompleted -= x); + }, x => _data.MediaSourceCompleted += x, x => _data.MediaSourceCompleted -= x); } /// @@ -7706,9 +7016,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } } @@ -7763,9 +7071,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AllPhotosCaptured += x, x => _data.AllPhotosCaptured -= x); + }, x => _data.AllPhotosCaptured += x, x => _data.AllPhotosCaptured -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7773,9 +7079,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionalReferencePhotoCaptured += x, x => _data.OptionalReferencePhotoCaptured -= x); + }, x => _data.OptionalReferencePhotoCaptured += x, x => _data.OptionalReferencePhotoCaptured -= x); } /// @@ -7800,9 +7104,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.AppCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CapturingChanged += x, x => _data.CapturingChanged -= x); + }, x => _data.CapturingChanged += x, x => _data.CapturingChanged -= x); } /// @@ -7827,9 +7129,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); } /// @@ -7854,9 +7154,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraStreamStateChanged += x, x => _data.CameraStreamStateChanged -= x); + }, x => _data.CameraStreamStateChanged += x, x => _data.CameraStreamStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7864,9 +7162,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CaptureDeviceExclusiveControlStatusChanged += x, x => _data.CaptureDeviceExclusiveControlStatusChanged -= x); + }, x => _data.CaptureDeviceExclusiveControlStatusChanged += x, x => _data.CaptureDeviceExclusiveControlStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7874,9 +7170,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFailedEventArgs errorEventArgs) => eventHandler((sender, errorEventArgs)); return Handler; - } - - , x => _data.Failed += x, x => _data.Failed -= x); + }, x => _data.Failed += x, x => _data.Failed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7884,9 +7178,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusChanged += x, x => _data.FocusChanged -= x); + }, x => _data.FocusChanged += x, x => _data.FocusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7894,9 +7186,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PhotoConfirmationCaptured += x, x => _data.PhotoConfirmationCaptured -= x); + }, x => _data.PhotoConfirmationCaptured += x, x => _data.PhotoConfirmationCaptured -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7904,9 +7194,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender) => eventHandler(sender); return Handler; - } - - , x => _data.RecordLimitationExceeded += x, x => _data.RecordLimitationExceeded -= x); + }, x => _data.RecordLimitationExceeded += x, x => _data.RecordLimitationExceeded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7914,9 +7202,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThermalStatusChanged += x, x => _data.ThermalStatusChanged -= x); + }, x => _data.ThermalStatusChanged += x, x => _data.ThermalStatusChanged -= x); } /// @@ -7941,9 +7227,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceSuspensionChanged += x, x => _data.SourceSuspensionChanged -= x); + }, x => _data.SourceSuspensionChanged += x, x => _data.SourceSuspensionChanged -= x); } } @@ -7982,9 +7266,7 @@ namespace Windows.Media.Capture.Core { void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7992,9 +7274,7 @@ namespace Windows.Media.Capture.Core { void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -8041,9 +7321,7 @@ namespace Windows.Media.Capture.Frames { void Handler(global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -8068,9 +7346,7 @@ namespace Windows.Media.Capture.Frames { void Handler(global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); } /// @@ -8095,9 +7371,7 @@ namespace Windows.Media.Capture.Frames { void Handler(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } } @@ -8140,9 +7414,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8150,9 +7422,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingConnection sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -8177,9 +7447,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CastingDevicePickerDismissed += x, x => _data.CastingDevicePickerDismissed -= x); + }, x => _data.CastingDevicePickerDismissed += x, x => _data.CastingDevicePickerDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8187,9 +7455,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CastingDeviceSelected += x, x => _data.CastingDeviceSelected -= x); + }, x => _data.CastingDeviceSelected += x, x => _data.CastingDeviceSelected -= x); } } @@ -8228,9 +7494,7 @@ namespace Windows.Media.ContentRestrictions { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.RestrictionsChanged += x, x => _data.RestrictionsChanged -= x); + }, x => _data.RestrictionsChanged += x, x => _data.RestrictionsChanged -= x); } } @@ -8273,9 +7537,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaPropertiesChanged += x, x => _data.MediaPropertiesChanged -= x); + }, x => _data.MediaPropertiesChanged += x, x => _data.MediaPropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8283,9 +7545,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackInfoChanged += x, x => _data.PlaybackInfoChanged -= x); + }, x => _data.PlaybackInfoChanged += x, x => _data.PlaybackInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8293,9 +7553,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimelinePropertiesChanged += x, x => _data.TimelinePropertiesChanged -= x); + }, x => _data.TimelinePropertiesChanged += x, x => _data.TimelinePropertiesChanged -= x); } /// @@ -8320,9 +7578,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentSessionChanged += x, x => _data.CurrentSessionChanged -= x); + }, x => _data.CurrentSessionChanged += x, x => _data.CurrentSessionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8330,9 +7586,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionsChanged += x, x => _data.SessionsChanged -= x); + }, x => _data.SessionsChanged += x, x => _data.SessionsChanged -= x); } } @@ -8435,9 +7689,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); } /// @@ -8462,9 +7714,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FaceDetected += x, x => _data.FaceDetected -= x); + }, x => _data.FaceDetected += x, x => _data.FaceDetected -= x); } /// @@ -8489,9 +7739,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -8516,9 +7764,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Binding += x, x => _data.Binding -= x); + }, x => _data.Binding += x, x => _data.Binding -= x); } /// @@ -8543,9 +7789,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaBindingEventArgs sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); } /// @@ -8570,9 +7814,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenOperationCompleted += x, x => _data.OpenOperationCompleted -= x); + }, x => _data.OpenOperationCompleted += x, x => _data.OpenOperationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8580,9 +7822,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -8607,9 +7847,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InitializeMediaStreamSourceRequested += x, x => _data.InitializeMediaStreamSourceRequested -= x); + }, x => _data.InitializeMediaStreamSourceRequested += x, x => _data.InitializeMediaStreamSourceRequested -= x); } /// @@ -8634,9 +7872,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSample sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Processed += x, x => _data.Processed -= x); + }, x => _data.Processed += x, x => _data.Processed -= x); } /// @@ -8661,9 +7897,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8671,9 +7905,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Paused += x, x => _data.Paused -= x); + }, x => _data.Paused += x, x => _data.Paused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8681,9 +7913,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SampleRendered += x, x => _data.SampleRendered -= x); + }, x => _data.SampleRendered += x, x => _data.SampleRendered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8691,9 +7921,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SampleRequested += x, x => _data.SampleRequested -= x); + }, x => _data.SampleRequested += x, x => _data.SampleRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8701,9 +7929,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Starting += x, x => _data.Starting -= x); + }, x => _data.Starting += x, x => _data.Starting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8711,9 +7937,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SwitchStreamsRequested += x, x => _data.SwitchStreamsRequested -= x); + }, x => _data.SwitchStreamsRequested += x, x => _data.SwitchStreamsRequested -= x); } /// @@ -8738,9 +7962,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Aborted += x, x => _data.Aborted -= x); + }, x => _data.Aborted += x, x => _data.Aborted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8748,9 +7970,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8758,9 +7978,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8768,9 +7986,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateEnded += x, x => _data.UpdateEnded -= x); + }, x => _data.UpdateEnded += x, x => _data.UpdateEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8778,9 +7994,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateStarting += x, x => _data.UpdateStarting -= x); + }, x => _data.UpdateStarting += x, x => _data.UpdateStarting -= x); } /// @@ -8805,9 +8019,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceBufferAdded += x, x => _data.SourceBufferAdded -= x); + }, x => _data.SourceBufferAdded += x, x => _data.SourceBufferAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8815,9 +8027,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceBufferRemoved += x, x => _data.SourceBufferRemoved -= x); + }, x => _data.SourceBufferRemoved += x, x => _data.SourceBufferRemoved -= x); } /// @@ -8842,9 +8052,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8852,9 +8060,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Ended += x, x => _data.Ended -= x); + }, x => _data.Ended += x, x => _data.Ended -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8862,9 +8068,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -8889,9 +8093,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SceneAnalyzed += x, x => _data.SceneAnalyzed -= x); + }, x => _data.SceneAnalyzed += x, x => _data.SceneAnalyzed -= x); } /// @@ -8916,9 +8118,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CueEntered += x, x => _data.CueEntered -= x); + }, x => _data.CueEntered += x, x => _data.CueEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8926,9 +8126,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CueExited += x, x => _data.CueExited -= x); + }, x => _data.CueExited += x, x => _data.CueExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8936,9 +8134,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TrackFailed += x, x => _data.TrackFailed -= x); + }, x => _data.TrackFailed += x, x => _data.TrackFailed -= x); } /// @@ -8963,9 +8159,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Resolved += x, x => _data.Resolved -= x); + }, x => _data.Resolved += x, x => _data.Resolved -= x); } /// @@ -8990,9 +8184,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); } /// @@ -9017,9 +8209,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); } } @@ -9058,9 +8248,7 @@ namespace Windows.Media.Devices { void Handler(global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ModuleNotificationReceived += x, x => _data.ModuleNotificationReceived -= x); + }, x => _data.ModuleNotificationReceived += x, x => _data.ModuleNotificationReceived -= x); } } @@ -9099,9 +8287,7 @@ namespace Windows.Media.DialProtocol { void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DialDevicePickerDismissed += x, x => _data.DialDevicePickerDismissed -= x); + }, x => _data.DialDevicePickerDismissed += x, x => _data.DialDevicePickerDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9109,9 +8295,7 @@ namespace Windows.Media.DialProtocol { void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DialDeviceSelected += x, x => _data.DialDeviceSelected -= x); + }, x => _data.DialDeviceSelected += x, x => _data.DialDeviceSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9119,9 +8303,7 @@ namespace Windows.Media.DialProtocol { void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); } } @@ -9164,9 +8346,7 @@ namespace Windows.Media.Effects { void Handler(global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioCaptureEffectsChanged += x, x => _data.AudioCaptureEffectsChanged -= x); + }, x => _data.AudioCaptureEffectsChanged += x, x => _data.AudioCaptureEffectsChanged -= x); } /// @@ -9191,9 +8371,7 @@ namespace Windows.Media.Effects { void Handler(global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioRenderEffectsChanged += x, x => _data.AudioRenderEffectsChanged -= x); + }, x => _data.AudioRenderEffectsChanged += x, x => _data.AudioRenderEffectsChanged -= x); } } @@ -9232,9 +8410,7 @@ namespace Windows.Media.Import { void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemImported += x, x => _data.ItemImported -= x); + }, x => _data.ItemImported += x, x => _data.ItemImported -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9242,9 +8418,7 @@ namespace Windows.Media.Import { void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } } @@ -9323,9 +8497,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreakEnded += x, x => _data.BreakEnded -= x); + }, x => _data.BreakEnded += x, x => _data.BreakEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9333,9 +8505,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreakSkipped += x, x => _data.BreakSkipped -= x); + }, x => _data.BreakSkipped += x, x => _data.BreakSkipped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9343,9 +8513,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreaksSeekedOver += x, x => _data.BreaksSeekedOver -= x); + }, x => _data.BreaksSeekedOver += x, x => _data.BreaksSeekedOver -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9353,9 +8521,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreakStarted += x, x => _data.BreakStarted -= x); + }, x => _data.BreakStarted += x, x => _data.BreakStarted -= x); } /// @@ -9380,9 +8546,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakSchedule sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScheduleChanged += x, x => _data.ScheduleChanged -= x); + }, x => _data.ScheduleChanged += x, x => _data.ScheduleChanged -= x); } /// @@ -9407,9 +8571,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -9434,9 +8596,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutoRepeatModeReceived += x, x => _data.AutoRepeatModeReceived -= x); + }, x => _data.AutoRepeatModeReceived += x, x => _data.AutoRepeatModeReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9444,9 +8604,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FastForwardReceived += x, x => _data.FastForwardReceived -= x); + }, x => _data.FastForwardReceived += x, x => _data.FastForwardReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9454,9 +8612,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NextReceived += x, x => _data.NextReceived -= x); + }, x => _data.NextReceived += x, x => _data.NextReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9464,9 +8620,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PauseReceived += x, x => _data.PauseReceived -= x); + }, x => _data.PauseReceived += x, x => _data.PauseReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9474,9 +8628,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlayReceived += x, x => _data.PlayReceived -= x); + }, x => _data.PlayReceived += x, x => _data.PlayReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9484,9 +8636,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionReceived += x, x => _data.PositionReceived -= x); + }, x => _data.PositionReceived += x, x => _data.PositionReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9494,9 +8644,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PreviousReceived += x, x => _data.PreviousReceived -= x); + }, x => _data.PreviousReceived += x, x => _data.PreviousReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9504,9 +8652,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RateReceived += x, x => _data.RateReceived -= x); + }, x => _data.RateReceived += x, x => _data.RateReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9514,9 +8660,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RewindReceived += x, x => _data.RewindReceived -= x); + }, x => _data.RewindReceived += x, x => _data.RewindReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9524,9 +8668,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShuffleReceived += x, x => _data.ShuffleReceived -= x); + }, x => _data.ShuffleReceived += x, x => _data.ShuffleReceived -= x); } /// @@ -9551,9 +8693,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); } /// @@ -9578,9 +8718,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioTracksChanged += x, x => _data.AudioTracksChanged -= x); + }, x => _data.AudioTracksChanged += x, x => _data.AudioTracksChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9588,9 +8726,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimedMetadataTracksChanged += x, x => _data.TimedMetadataTracksChanged -= x); + }, x => _data.TimedMetadataTracksChanged += x, x => _data.TimedMetadataTracksChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9598,9 +8734,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoTracksChanged += x, x => _data.VideoTracksChanged -= x); + }, x => _data.VideoTracksChanged += x, x => _data.VideoTracksChanged -= x); } /// @@ -9625,9 +8759,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9635,9 +8767,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemFailed += x, x => _data.ItemFailed -= x); + }, x => _data.ItemFailed += x, x => _data.ItemFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9645,9 +8775,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemOpened += x, x => _data.ItemOpened -= x); + }, x => _data.ItemOpened += x, x => _data.ItemOpened -= x); } /// @@ -9672,9 +8800,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferedRangesChanged += x, x => _data.BufferedRangesChanged -= x); + }, x => _data.BufferedRangesChanged += x, x => _data.BufferedRangesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9682,9 +8808,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9692,9 +8816,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9702,9 +8824,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9712,9 +8832,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9722,9 +8840,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NaturalDurationChanged += x, x => _data.NaturalDurationChanged -= x); + }, x => _data.NaturalDurationChanged += x, x => _data.NaturalDurationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9732,9 +8848,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NaturalVideoSizeChanged += x, x => _data.NaturalVideoSizeChanged -= x); + }, x => _data.NaturalVideoSizeChanged += x, x => _data.NaturalVideoSizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9742,9 +8856,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackRateChanged += x, x => _data.PlaybackRateChanged -= x); + }, x => _data.PlaybackRateChanged += x, x => _data.PlaybackRateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9752,9 +8864,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackStateChanged += x, x => _data.PlaybackStateChanged -= x); + }, x => _data.PlaybackStateChanged += x, x => _data.PlaybackStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9762,9 +8872,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlayedRangesChanged += x, x => _data.PlayedRangesChanged -= x); + }, x => _data.PlayedRangesChanged += x, x => _data.PlayedRangesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9772,9 +8880,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9782,9 +8888,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeekableRangesChanged += x, x => _data.SeekableRangesChanged -= x); + }, x => _data.SeekableRangesChanged += x, x => _data.SeekableRangesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9792,9 +8896,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9802,9 +8904,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SupportedPlaybackRatesChanged += x, x => _data.SupportedPlaybackRatesChanged -= x); + }, x => _data.SupportedPlaybackRatesChanged += x, x => _data.SupportedPlaybackRatesChanged -= x); } /// @@ -9829,9 +8929,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PresentationModeChanged += x, x => _data.PresentationModeChanged -= x); + }, x => _data.PresentationModeChanged += x, x => _data.PresentationModeChanged -= x); } /// @@ -9856,9 +8954,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -9883,9 +8979,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9893,9 +8987,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9903,9 +8995,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9913,9 +9003,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsMutedChanged += x, x => _data.IsMutedChanged -= x); + }, x => _data.IsMutedChanged += x, x => _data.IsMutedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9923,9 +9011,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9933,9 +9019,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9943,9 +9027,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9953,9 +9035,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaPlayerRateChanged += x, x => _data.MediaPlayerRateChanged -= x); + }, x => _data.MediaPlayerRateChanged += x, x => _data.MediaPlayerRateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9963,9 +9043,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackMediaMarkerReached += x, x => _data.PlaybackMediaMarkerReached -= x); + }, x => _data.PlaybackMediaMarkerReached += x, x => _data.PlaybackMediaMarkerReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9973,9 +9051,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9983,9 +9059,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceChanged += x, x => _data.SourceChanged -= x); + }, x => _data.SourceChanged += x, x => _data.SourceChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9993,9 +9067,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SubtitleFrameChanged += x, x => _data.SubtitleFrameChanged -= x); + }, x => _data.SubtitleFrameChanged += x, x => _data.SubtitleFrameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10003,9 +9075,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoFrameAvailable += x, x => _data.VideoFrameAvailable -= x); + }, x => _data.VideoFrameAvailable += x, x => _data.VideoFrameAvailable -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10013,9 +9083,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); } } @@ -10062,9 +9130,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Error += x, x => _data.Error -= x); + }, x => _data.Error += x, x => _data.Error -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10072,9 +9138,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10082,9 +9146,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Transferred += x, x => _data.Transferred -= x); + }, x => _data.Transferred += x, x => _data.Transferred -= x); } /// @@ -10109,9 +9171,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRequested += x, x => _data.SourceRequested -= x); + }, x => _data.SourceRequested += x, x => _data.SourceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10119,9 +9179,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceSelected += x, x => _data.SourceSelected -= x); + }, x => _data.SourceSelected += x, x => _data.SourceSelected -= x); } /// @@ -10146,9 +9204,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentTimeChangeRequested += x, x => _data.CurrentTimeChangeRequested -= x); + }, x => _data.CurrentTimeChangeRequested += x, x => _data.CurrentTimeChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10156,9 +9212,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MuteChangeRequested += x, x => _data.MuteChangeRequested -= x); + }, x => _data.MuteChangeRequested += x, x => _data.MuteChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10166,9 +9220,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PauseRequested += x, x => _data.PauseRequested -= x); + }, x => _data.PauseRequested += x, x => _data.PauseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10176,9 +9228,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10186,9 +9236,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlayRequested += x, x => _data.PlayRequested -= x); + }, x => _data.PlayRequested += x, x => _data.PlayRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10196,9 +9244,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceChangeRequested += x, x => _data.SourceChangeRequested -= x); + }, x => _data.SourceChangeRequested += x, x => _data.SourceChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10206,9 +9252,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StopRequested += x, x => _data.StopRequested -= x); + }, x => _data.StopRequested += x, x => _data.StopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10216,9 +9260,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimeUpdateRequested += x, x => _data.TimeUpdateRequested -= x); + }, x => _data.TimeUpdateRequested += x, x => _data.TimeUpdateRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10226,9 +9268,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VolumeChangeRequested += x, x => _data.VolumeChangeRequested -= x); + }, x => _data.VolumeChangeRequested += x, x => _data.VolumeChangeRequested -= x); } } @@ -10271,9 +9311,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.HdcpSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProtectionChanged += x, x => _data.ProtectionChanged -= x); + }, x => _data.ProtectionChanged += x, x => _data.ProtectionChanged -= x); } /// @@ -10298,9 +9336,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ComponentLoadFailedEventArgs e) => eventHandler((sender, e)); return Handler; - } - - , x => _data.ComponentLoadFailed += x, x => _data.ComponentLoadFailed -= x); + }, x => _data.ComponentLoadFailed += x, x => _data.ComponentLoadFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10308,9 +9344,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.MediaProtectionManager sender) => eventHandler(sender); return Handler; - } - - , x => _data.RebootNeeded += x, x => _data.RebootNeeded -= x); + }, x => _data.RebootNeeded += x, x => _data.RebootNeeded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10318,9 +9352,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ServiceRequestedEventArgs e) => eventHandler((sender, e)); return Handler; - } - - , x => _data.ServiceRequested += x, x => _data.ServiceRequested -= x); + }, x => _data.ServiceRequested += x, x => _data.ServiceRequested -= x); } } @@ -10359,9 +9391,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ClosedCaptionDataReceived += x, x => _data.ClosedCaptionDataReceived -= x); + }, x => _data.ClosedCaptionDataReceived += x, x => _data.ClosedCaptionDataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10369,9 +9399,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LicenseFetchCompleted += x, x => _data.LicenseFetchCompleted -= x); + }, x => _data.LicenseFetchCompleted += x, x => _data.LicenseFetchCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10379,9 +9407,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProximityDetectionCompleted += x, x => _data.ProximityDetectionCompleted -= x); + }, x => _data.ProximityDetectionCompleted += x, x => _data.ProximityDetectionCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10389,9 +9415,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RegistrationCompleted += x, x => _data.RegistrationCompleted -= x); + }, x => _data.RegistrationCompleted += x, x => _data.RegistrationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10399,9 +9423,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReRegistrationNeeded += x, x => _data.ReRegistrationNeeded -= x); + }, x => _data.ReRegistrationNeeded += x, x => _data.ReRegistrationNeeded -= x); } } @@ -10444,9 +9466,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10454,9 +9474,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResultGenerated += x, x => _data.ResultGenerated -= x); + }, x => _data.ResultGenerated += x, x => _data.ResultGenerated -= x); } /// @@ -10481,9 +9499,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HypothesisGenerated += x, x => _data.HypothesisGenerated -= x); + }, x => _data.HypothesisGenerated += x, x => _data.HypothesisGenerated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10491,9 +9507,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RecognitionQualityDegrading += x, x => _data.RecognitionQualityDegrading -= x); + }, x => _data.RecognitionQualityDegrading += x, x => _data.RecognitionQualityDegrading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10501,9 +9515,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -10546,9 +9558,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadBitrateChanged += x, x => _data.DownloadBitrateChanged -= x); + }, x => _data.DownloadBitrateChanged += x, x => _data.DownloadBitrateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10556,9 +9566,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10566,9 +9574,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10576,9 +9582,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadRequested += x, x => _data.DownloadRequested -= x); + }, x => _data.DownloadRequested += x, x => _data.DownloadRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10586,9 +9590,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackBitrateChanged += x, x => _data.PlaybackBitrateChanged -= x); + }, x => _data.PlaybackBitrateChanged += x, x => _data.PlaybackBitrateChanged -= x); } /// @@ -10613,9 +9615,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DiagnosticAvailable += x, x => _data.DiagnosticAvailable -= x); + }, x => _data.DiagnosticAvailable += x, x => _data.DiagnosticAvailable -= x); } } @@ -10654,9 +9654,7 @@ namespace Windows.Networking.BackgroundTransfer { void Handler(global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RangesDownloaded += x, x => _data.RangesDownloaded -= x); + }, x => _data.RangesDownloaded += x, x => _data.RangesDownloaded -= x); } } @@ -10719,9 +9717,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESim sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProfileChanged += x, x => _data.ProfileChanged -= x); + }, x => _data.ProfileChanged += x, x => _data.ProfileChanged -= x); } /// @@ -10746,9 +9742,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -10773,9 +9767,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10783,9 +9775,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10793,9 +9783,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10803,9 +9791,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10813,9 +9799,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -10840,9 +9824,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountAdded += x, x => _data.AccountAdded -= x); + }, x => _data.AccountAdded += x, x => _data.AccountAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10850,9 +9832,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountRemoved += x, x => _data.AccountRemoved -= x); + }, x => _data.AccountRemoved += x, x => _data.AccountRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10860,9 +9840,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountUpdated += x, x => _data.AccountUpdated -= x); + }, x => _data.AccountUpdated += x, x => _data.AccountUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10870,9 +9848,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10880,9 +9856,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -10907,9 +9881,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); } /// @@ -10934,9 +9906,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsInEmergencyCallModeChanged += x, x => _data.IsInEmergencyCallModeChanged -= x); + }, x => _data.IsInEmergencyCallModeChanged += x, x => _data.IsInEmergencyCallModeChanged -= x); } /// @@ -10961,9 +9931,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TransmissionStateChanged += x, x => _data.TransmissionStateChanged -= x); + }, x => _data.TransmissionStateChanged += x, x => _data.TransmissionStateChanged -= x); } } @@ -11006,9 +9974,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11016,9 +9982,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11026,9 +9990,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11036,9 +9998,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11046,9 +10006,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -11073,9 +10031,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); return Handler; - } - - , x => _data.DeviceArrived += x, x => _data.DeviceArrived -= x); + }, x => _data.DeviceArrived += x, x => _data.DeviceArrived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11083,9 +10039,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); return Handler; - } - - , x => _data.DeviceDeparted += x, x => _data.DeviceDeparted -= x); + }, x => _data.DeviceDeparted += x, x => _data.DeviceDeparted -= x); } } @@ -11124,9 +10078,7 @@ namespace Windows.Networking.PushNotifications { void Handler(global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PushNotificationReceived += x, x => _data.PushNotificationReceived -= x); + }, x => _data.PushNotificationReceived += x, x => _data.PushNotificationReceived -= x); } } @@ -11165,9 +10117,7 @@ namespace Windows.Networking.ServiceDiscovery.Dnssd { void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11175,9 +10125,7 @@ namespace Windows.Networking.ServiceDiscovery.Dnssd { void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11185,9 +10133,7 @@ namespace Windows.Networking.ServiceDiscovery.Dnssd { void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -11250,9 +10196,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } /// @@ -11277,9 +10221,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } /// @@ -11304,9 +10246,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11314,9 +10254,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11324,9 +10262,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); } /// @@ -11351,9 +10287,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11361,9 +10295,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } /// @@ -11388,9 +10320,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } /// @@ -11415,9 +10345,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionReceived += x, x => _data.ConnectionReceived -= x); + }, x => _data.ConnectionReceived += x, x => _data.ConnectionReceived -= x); } /// @@ -11442,9 +10370,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11452,9 +10378,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); } } @@ -11493,9 +10417,7 @@ namespace Windows.Networking.Vpn { void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActivityChange += x, x => _data.ActivityChange -= x); + }, x => _data.ActivityChange += x, x => _data.ActivityChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11503,9 +10425,7 @@ namespace Windows.Networking.Vpn { void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActivityStateChange += x, x => _data.ActivityStateChange -= x); + }, x => _data.ActivityStateChange += x, x => _data.ActivityStateChange -= x); } } @@ -11552,9 +10472,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RawCoordinateSystemAdjusted += x, x => _data.RawCoordinateSystemAdjusted -= x); + }, x => _data.RawCoordinateSystemAdjusted += x, x => _data.RawCoordinateSystemAdjusted -= x); } /// @@ -11579,9 +10497,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11589,9 +10505,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11599,9 +10513,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11609,9 +10521,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -11636,9 +10546,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LocatabilityChanged += x, x => _data.LocatabilityChanged -= x); + }, x => _data.LocatabilityChanged += x, x => _data.LocatabilityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11646,9 +10554,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionalTrackingDeactivating += x, x => _data.PositionalTrackingDeactivating -= x); + }, x => _data.PositionalTrackingDeactivating += x, x => _data.PositionalTrackingDeactivating -= x); } } @@ -11687,9 +10593,7 @@ namespace Windows.Perception.Spatial.Surfaces { void Handler(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ObservedSurfacesChanged += x, x => _data.ObservedSurfacesChanged -= x); + }, x => _data.ObservedSurfacesChanged += x, x => _data.ObservedSurfacesChanged -= x); } } @@ -11728,9 +10632,7 @@ namespace Windows.Phone.Devices.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingChargePercentChanged += x, x => _data.RemainingChargePercentChanged -= x); + }, x => _data.RemainingChargePercentChanged += x, x => _data.RemainingChargePercentChanged -= x); } } @@ -11769,9 +10671,7 @@ namespace Windows.Phone.Media.Devices { void Handler(global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioEndpointChanged += x, x => _data.AudioEndpointChanged -= x); + }, x => _data.AudioEndpointChanged += x, x => _data.AudioEndpointChanged -= x); } } @@ -11810,9 +10710,7 @@ namespace Windows.Security.Authentication.Web.Core { void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DefaultSignInAccountChanged += x, x => _data.DefaultSignInAccountChanged -= x); + }, x => _data.DefaultSignInAccountChanged += x, x => _data.DefaultSignInAccountChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11820,9 +10718,7 @@ namespace Windows.Security.Authentication.Web.Core { void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11830,9 +10726,7 @@ namespace Windows.Security.Authentication.Web.Core { void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -11871,9 +10765,7 @@ namespace Windows.Security.Credentials { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } } @@ -11912,9 +10804,7 @@ namespace Windows.Services.Maps.OfflineMaps { void Handler(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } } @@ -11965,9 +10855,7 @@ namespace Windows.Storage { void Handler(global::Windows.Storage.ApplicationData sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataChanged += x, x => _data.DataChanged -= x); + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); } /// @@ -11992,9 +10880,7 @@ namespace Windows.Storage { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -12019,9 +10905,7 @@ namespace Windows.Storage { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -12046,9 +10930,7 @@ namespace Windows.Storage { void Handler(global::Windows.Storage.StorageLibrary sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DefinitionChanged += x, x => _data.DefinitionChanged -= x); + }, x => _data.DefinitionChanged += x, x => _data.DefinitionChanged -= x); } } @@ -12087,9 +10969,7 @@ namespace Windows.Storage.AccessCache { void Handler(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); } } @@ -12136,9 +11016,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12146,9 +11024,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); } /// @@ -12173,9 +11049,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12183,9 +11057,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); } /// @@ -12210,9 +11082,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12220,9 +11090,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); } } @@ -12265,9 +11133,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12275,9 +11141,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileRemoved += x, x => _data.FileRemoved -= x); + }, x => _data.FileRemoved += x, x => _data.FileRemoved -= x); } /// @@ -12302,9 +11166,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileNameChanged += x, x => _data.FileNameChanged -= x); + }, x => _data.FileNameChanged += x, x => _data.FileNameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12312,9 +11174,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetFileRequested += x, x => _data.TargetFileRequested -= x); + }, x => _data.TargetFileRequested += x, x => _data.TargetFileRequested -= x); } } @@ -12353,9 +11213,7 @@ namespace Windows.Storage.Provider { void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileUpdateRequested += x, x => _data.FileUpdateRequested -= x); + }, x => _data.FileUpdateRequested += x, x => _data.FileUpdateRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12363,9 +11221,7 @@ namespace Windows.Storage.Provider { void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UIRequested += x, x => _data.UIRequested -= x); + }, x => _data.UIRequested += x, x => _data.UIRequested -= x); } } @@ -12416,9 +11272,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12426,9 +11280,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } /// @@ -12453,9 +11305,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12463,9 +11313,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } /// @@ -12490,9 +11338,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12500,9 +11346,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } /// @@ -12527,9 +11371,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12537,9 +11379,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } } @@ -12594,9 +11434,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12604,9 +11442,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12614,9 +11450,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12624,9 +11458,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -12651,9 +11483,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12661,9 +11491,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12671,9 +11499,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ExecutionStateChanged += x, x => _data.ExecutionStateChanged -= x); + }, x => _data.ExecutionStateChanged += x, x => _data.ExecutionStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12681,9 +11507,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12691,9 +11515,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -12718,9 +11540,7 @@ namespace Windows.System { void Handler(global::Windows.System.DispatcherQueue sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShutdownCompleted += x, x => _data.ShutdownCompleted -= x); + }, x => _data.ShutdownCompleted += x, x => _data.ShutdownCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12728,9 +11548,7 @@ namespace Windows.System { void Handler(global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShutdownStarting += x, x => _data.ShutdownStarting -= x); + }, x => _data.ShutdownStarting += x, x => _data.ShutdownStarting -= x); } /// @@ -12755,9 +11573,7 @@ namespace Windows.System { void Handler(global::Windows.System.DispatcherQueueTimer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// @@ -12782,9 +11598,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12792,9 +11606,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AuthenticationStatusChanged += x, x => _data.AuthenticationStatusChanged -= x); + }, x => _data.AuthenticationStatusChanged += x, x => _data.AuthenticationStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12802,9 +11614,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AuthenticationStatusChanging += x, x => _data.AuthenticationStatusChanging -= x); + }, x => _data.AuthenticationStatusChanging += x, x => _data.AuthenticationStatusChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12812,9 +11622,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12822,9 +11630,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12832,9 +11638,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12842,9 +11646,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -12883,9 +11685,7 @@ namespace Windows.System.Diagnostics.DevicePortal { void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12893,9 +11693,7 @@ namespace Windows.System.Diagnostics.DevicePortal { void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); } } @@ -12934,9 +11732,7 @@ namespace Windows.System.Preview { void Handler(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PostureChanged += x, x => _data.PostureChanged -= x); + }, x => _data.PostureChanged += x, x => _data.PostureChanged -= x); } } @@ -12999,9 +11795,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Disconnected += x, x => _data.Disconnected -= x); + }, x => _data.Disconnected += x, x => _data.Disconnected -= x); } /// @@ -13026,9 +11820,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.JoinRequested += x, x => _data.JoinRequested -= x); + }, x => _data.JoinRequested += x, x => _data.JoinRequested -= x); } /// @@ -13053,9 +11845,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InvitationReceived += x, x => _data.InvitationReceived -= x); + }, x => _data.InvitationReceived += x, x => _data.InvitationReceived -= x); } /// @@ -13080,9 +11870,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValueSetReceived += x, x => _data.ValueSetReceived -= x); + }, x => _data.ValueSetReceived += x, x => _data.ValueSetReceived -= x); } /// @@ -13107,9 +11895,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13117,9 +11903,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13127,9 +11911,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); } /// @@ -13154,9 +11936,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13164,9 +11944,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13174,9 +11952,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -13201,9 +11977,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13211,9 +11985,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13221,9 +11993,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteSystemAdded += x, x => _data.RemoteSystemAdded -= x); + }, x => _data.RemoteSystemAdded += x, x => _data.RemoteSystemAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13231,9 +12001,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteSystemRemoved += x, x => _data.RemoteSystemRemoved -= x); + }, x => _data.RemoteSystemRemoved += x, x => _data.RemoteSystemRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13241,9 +12009,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteSystemUpdated += x, x => _data.RemoteSystemUpdated -= x); + }, x => _data.RemoteSystemUpdated += x, x => _data.RemoteSystemUpdated -= x); } } @@ -13282,9 +12048,7 @@ namespace Windows.UI.Accessibility { void Handler(global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenReaderPositionChanged += x, x => _data.ScreenReaderPositionChanged -= x); + }, x => _data.ScreenReaderPositionChanged += x, x => _data.ScreenReaderPositionChanged -= x); } } @@ -13323,9 +12087,7 @@ namespace Windows.UI.ApplicationSettings { void Handler(global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountCommandsRequested += x, x => _data.AccountCommandsRequested -= x); + }, x => _data.AccountCommandsRequested += x, x => _data.AccountCommandsRequested -= x); } } @@ -13376,9 +12138,7 @@ namespace Windows.UI.Composition { void Handler(global::Windows.UI.Composition.CompositionCapabilities sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } /// @@ -13403,9 +12163,7 @@ namespace Windows.UI.Composition { void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -13430,9 +12188,7 @@ namespace Windows.UI.Composition { void Handler(global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RenderingDeviceReplaced += x, x => _data.RenderingDeviceReplaced -= x); + }, x => _data.RenderingDeviceReplaced += x, x => _data.RenderingDeviceReplaced -= x); } /// @@ -13457,9 +12213,7 @@ namespace Windows.UI.Composition { void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } } @@ -13498,9 +12252,7 @@ namespace Windows.UI.Composition.Core { void Handler(global::Windows.UI.Composition.Core.CompositorController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CommitNeeded += x, x => _data.CommitNeeded -= x); + }, x => _data.CommitNeeded += x, x => _data.CommitNeeded -= x); } } @@ -13579,9 +12331,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); } /// @@ -13606,9 +12356,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13616,9 +12364,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13626,9 +12372,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13636,9 +12380,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13646,9 +12388,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13656,9 +12396,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13666,9 +12404,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13676,9 +12412,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13686,9 +12420,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13696,9 +12428,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13706,9 +12436,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13716,9 +12444,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13726,9 +12452,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13736,9 +12460,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13746,9 +12468,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); } /// @@ -13773,9 +12493,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); } /// @@ -13800,9 +12518,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13810,9 +12526,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13820,9 +12534,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13830,9 +12542,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13840,9 +12550,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13850,9 +12558,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13860,9 +12566,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13870,9 +12574,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); } /// @@ -13897,9 +12599,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13907,9 +12607,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13917,9 +12615,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13927,9 +12623,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13937,9 +12631,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13947,9 +12639,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13957,9 +12647,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13967,9 +12655,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13977,9 +12663,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13987,9 +12671,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13997,9 +12679,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14007,9 +12687,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14017,9 +12695,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14027,9 +12703,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14037,9 +12711,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14047,9 +12719,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14057,9 +12727,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14067,9 +12735,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14077,9 +12743,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResizeCompleted += x, x => _data.ResizeCompleted -= x); + }, x => _data.ResizeCompleted += x, x => _data.ResizeCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14087,9 +12751,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResizeStarted += x, x => _data.ResizeStarted -= x); + }, x => _data.ResizeStarted += x, x => _data.ResizeStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14097,9 +12759,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14107,9 +12767,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14117,9 +12775,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } /// @@ -14144,9 +12800,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); } /// @@ -14171,9 +12825,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); } /// @@ -14198,9 +12850,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14208,9 +12858,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14218,9 +12866,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14228,9 +12874,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14238,9 +12882,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14248,9 +12890,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14258,9 +12898,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); } /// @@ -14285,9 +12923,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14295,9 +12931,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14305,9 +12939,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); } /// @@ -14332,9 +12964,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14342,9 +12972,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14352,9 +12980,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14362,9 +12988,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14372,9 +12996,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14382,9 +13004,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14392,9 +13012,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14402,9 +13020,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14412,9 +13028,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14422,9 +13036,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14432,9 +13044,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14442,9 +13052,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14452,9 +13060,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14462,9 +13068,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14472,9 +13076,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14482,9 +13084,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14492,9 +13092,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } /// @@ -14519,9 +13117,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.BackRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackRequested += x, x => _data.BackRequested -= x); + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); } } @@ -14560,9 +13156,7 @@ namespace Windows.UI.Core.Preview { void Handler(object sender, global::Windows.UI.Core.Preview.SystemNavigationCloseRequestedPreviewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); } } @@ -14617,9 +13211,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14627,9 +13219,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14637,9 +13227,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Starting += x, x => _data.Starting -= x); + }, x => _data.Starting += x, x => _data.Starting -= x); } /// @@ -14664,9 +13252,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CrossSliding += x, x => _data.CrossSliding -= x); + }, x => _data.CrossSliding += x, x => _data.CrossSliding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14674,9 +13260,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Dragging += x, x => _data.Dragging -= x); + }, x => _data.Dragging += x, x => _data.Dragging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14684,9 +13268,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Holding += x, x => _data.Holding -= x); + }, x => _data.Holding += x, x => _data.Holding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14694,9 +13276,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14704,9 +13284,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14714,9 +13292,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14724,9 +13300,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14734,9 +13308,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RightTapped += x, x => _data.RightTapped -= x); + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14744,9 +13316,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -14771,9 +13341,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14781,9 +13349,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); } /// @@ -14808,9 +13374,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonClicked += x, x => _data.ButtonClicked -= x); + }, x => _data.ButtonClicked += x, x => _data.ButtonClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14818,9 +13382,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonHolding += x, x => _data.ButtonHolding -= x); + }, x => _data.ButtonHolding += x, x => _data.ButtonHolding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14828,9 +13390,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14838,9 +13398,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonReleased += x, x => _data.ButtonReleased -= x); + }, x => _data.ButtonReleased += x, x => _data.ButtonReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14848,9 +13406,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ControlAcquired += x, x => _data.ControlAcquired -= x); + }, x => _data.ControlAcquired += x, x => _data.ControlAcquired -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14858,9 +13414,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ControlLost += x, x => _data.ControlLost -= x); + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14868,9 +13422,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RotationChanged += x, x => _data.RotationChanged -= x); + }, x => _data.RotationChanged += x, x => _data.RotationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14878,9 +13430,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenContactContinued += x, x => _data.ScreenContactContinued -= x); + }, x => _data.ScreenContactContinued += x, x => _data.ScreenContactContinued -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14888,9 +13438,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenContactEnded += x, x => _data.ScreenContactEnded -= x); + }, x => _data.ScreenContactEnded += x, x => _data.ScreenContactEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14898,9 +13446,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenContactStarted += x, x => _data.ScreenContactStarted -= x); + }, x => _data.ScreenContactStarted += x, x => _data.ScreenContactStarted -= x); } /// @@ -14925,9 +13471,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialControllerMenuItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } } @@ -14974,9 +13518,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokesCollected += x, x => _data.StrokesCollected -= x); + }, x => _data.StrokesCollected += x, x => _data.StrokesCollected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14984,9 +13526,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokesErased += x, x => _data.StrokesErased -= x); + }, x => _data.StrokesErased += x, x => _data.StrokesErased -= x); } /// @@ -15011,9 +13551,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeCanceled += x, x => _data.StrokeCanceled -= x); + }, x => _data.StrokeCanceled += x, x => _data.StrokeCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15021,9 +13559,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeContinued += x, x => _data.StrokeContinued -= x); + }, x => _data.StrokeContinued += x, x => _data.StrokeContinued -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15031,9 +13567,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeEnded += x, x => _data.StrokeEnded -= x); + }, x => _data.StrokeEnded += x, x => _data.StrokeEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15041,9 +13575,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeStarted += x, x => _data.StrokeStarted -= x); + }, x => _data.StrokeStarted += x, x => _data.StrokeStarted -= x); } /// @@ -15068,9 +13600,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15078,9 +13608,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15088,9 +13616,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerHovered += x, x => _data.PointerHovered -= x); + }, x => _data.PointerHovered += x, x => _data.PointerHovered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15098,9 +13624,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerLost += x, x => _data.PointerLost -= x); + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15108,9 +13632,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15118,9 +13640,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15128,9 +13648,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); } } @@ -15173,9 +13691,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntering += x, x => _data.PointerEntering -= x); + }, x => _data.PointerEntering += x, x => _data.PointerEntering -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15183,9 +13699,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExiting += x, x => _data.PointerExiting -= x); + }, x => _data.PointerExiting += x, x => _data.PointerExiting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15193,9 +13707,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerHovering += x, x => _data.PointerHovering -= x); + }, x => _data.PointerHovering += x, x => _data.PointerHovering -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15203,9 +13715,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerLost += x, x => _data.PointerLost -= x); + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15213,9 +13723,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoving += x, x => _data.PointerMoving -= x); + }, x => _data.PointerMoving += x, x => _data.PointerMoving -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15223,9 +13731,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressing += x, x => _data.PointerPressing -= x); + }, x => _data.PointerPressing += x, x => _data.PointerPressing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15233,9 +13739,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleasing += x, x => _data.PointerReleasing -= x); + }, x => _data.PointerReleasing += x, x => _data.PointerReleasing -= x); } /// @@ -15260,9 +13764,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeCanceled += x, x => _data.WetStrokeCanceled -= x); + }, x => _data.WetStrokeCanceled += x, x => _data.WetStrokeCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15270,9 +13772,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeCompleted += x, x => _data.WetStrokeCompleted -= x); + }, x => _data.WetStrokeCompleted += x, x => _data.WetStrokeCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15280,9 +13780,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeContinuing += x, x => _data.WetStrokeContinuing -= x); + }, x => _data.WetStrokeContinuing += x, x => _data.WetStrokeContinuing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15290,9 +13788,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeStarting += x, x => _data.WetStrokeStarting -= x); + }, x => _data.WetStrokeStarting += x, x => _data.WetStrokeStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15300,9 +13796,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeStopping += x, x => _data.WetStrokeStopping -= x); + }, x => _data.WetStrokeStopping += x, x => _data.WetStrokeStopping -= x); } } @@ -15345,9 +13839,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HoldCanceled += x, x => _data.HoldCanceled -= x); + }, x => _data.HoldCanceled += x, x => _data.HoldCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15355,9 +13847,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HoldCompleted += x, x => _data.HoldCompleted -= x); + }, x => _data.HoldCompleted += x, x => _data.HoldCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15365,9 +13855,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HoldStarted += x, x => _data.HoldStarted -= x); + }, x => _data.HoldStarted += x, x => _data.HoldStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15375,9 +13863,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationCanceled += x, x => _data.ManipulationCanceled -= x); + }, x => _data.ManipulationCanceled += x, x => _data.ManipulationCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15385,9 +13871,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15395,9 +13879,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15405,9 +13887,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15415,9 +13895,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCanceled += x, x => _data.NavigationCanceled -= x); + }, x => _data.NavigationCanceled += x, x => _data.NavigationCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15425,9 +13903,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15435,9 +13911,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarted += x, x => _data.NavigationStarted -= x); + }, x => _data.NavigationStarted += x, x => _data.NavigationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15445,9 +13919,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationUpdated += x, x => _data.NavigationUpdated -= x); + }, x => _data.NavigationUpdated += x, x => _data.NavigationUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15455,9 +13927,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RecognitionEnded += x, x => _data.RecognitionEnded -= x); + }, x => _data.RecognitionEnded += x, x => _data.RecognitionEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15465,9 +13935,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RecognitionStarted += x, x => _data.RecognitionStarted -= x); + }, x => _data.RecognitionStarted += x, x => _data.RecognitionStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15475,9 +13943,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -15502,9 +13968,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InteractionDetected += x, x => _data.InteractionDetected -= x); + }, x => _data.InteractionDetected += x, x => _data.InteractionDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15512,9 +13976,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceDetected += x, x => _data.SourceDetected -= x); + }, x => _data.SourceDetected += x, x => _data.SourceDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15522,9 +13984,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceLost += x, x => _data.SourceLost -= x); + }, x => _data.SourceLost += x, x => _data.SourceLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15532,9 +13992,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourcePressed += x, x => _data.SourcePressed -= x); + }, x => _data.SourcePressed += x, x => _data.SourcePressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15542,9 +14000,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceReleased += x, x => _data.SourceReleased -= x); + }, x => _data.SourceReleased += x, x => _data.SourceReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15552,9 +14008,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); } } @@ -15597,9 +14051,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotification sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15607,9 +14059,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15617,9 +14067,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Failed += x, x => _data.Failed -= x); + }, x => _data.Failed += x, x => _data.Failed -= x); } /// @@ -15644,9 +14092,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScheduledToastNotificationShowing += x, x => _data.ScheduledToastNotificationShowing -= x); + }, x => _data.ScheduledToastNotificationShowing += x, x => _data.ScheduledToastNotificationShowing -= x); } } @@ -15685,9 +14131,7 @@ namespace Windows.UI.Notifications.Management { void Handler(global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NotificationChanged += x, x => _data.NotificationChanged -= x); + }, x => _data.NotificationChanged += x, x => _data.NotificationChanged -= x); } } @@ -15726,9 +14170,7 @@ namespace Windows.UI.StartScreen { void Handler(global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisualElementsRequested += x, x => _data.VisualElementsRequested -= x); + }, x => _data.VisualElementsRequested += x, x => _data.VisualElementsRequested -= x); } } @@ -15771,9 +14213,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompositionCompleted += x, x => _data.CompositionCompleted -= x); + }, x => _data.CompositionCompleted += x, x => _data.CompositionCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15781,9 +14221,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompositionStarted += x, x => _data.CompositionStarted -= x); + }, x => _data.CompositionStarted += x, x => _data.CompositionStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15791,9 +14229,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusRemoved += x, x => _data.FocusRemoved -= x); + }, x => _data.FocusRemoved += x, x => _data.FocusRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15801,9 +14237,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FormatUpdating += x, x => _data.FormatUpdating -= x); + }, x => _data.FormatUpdating += x, x => _data.FormatUpdating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15811,9 +14245,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LayoutRequested += x, x => _data.LayoutRequested -= x); + }, x => _data.LayoutRequested += x, x => _data.LayoutRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15821,9 +14253,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NotifyFocusLeaveCompleted += x, x => _data.NotifyFocusLeaveCompleted -= x); + }, x => _data.NotifyFocusLeaveCompleted += x, x => _data.NotifyFocusLeaveCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15831,9 +14261,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionRequested += x, x => _data.SelectionRequested -= x); + }, x => _data.SelectionRequested += x, x => _data.SelectionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15841,9 +14269,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionUpdating += x, x => _data.SelectionUpdating -= x); + }, x => _data.SelectionUpdating += x, x => _data.SelectionUpdating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15851,9 +14277,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextRequested += x, x => _data.TextRequested -= x); + }, x => _data.TextRequested += x, x => _data.TextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15861,9 +14285,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextUpdating += x, x => _data.TextUpdating -= x); + }, x => _data.TextUpdating += x, x => _data.TextUpdating -= x); } /// @@ -15888,9 +14310,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); } } @@ -15945,9 +14365,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HighContrastChanged += x, x => _data.HighContrastChanged -= x); + }, x => _data.HighContrastChanged += x, x => _data.HighContrastChanged -= x); } /// @@ -15972,9 +14390,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Consolidated += x, x => _data.Consolidated -= x); + }, x => _data.Consolidated += x, x => _data.Consolidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15982,9 +14398,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisibleBoundsChanged += x, x => _data.VisibleBoundsChanged -= x); + }, x => _data.VisibleBoundsChanged += x, x => _data.VisibleBoundsChanged -= x); } /// @@ -16009,9 +14423,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Hiding += x, x => _data.Hiding -= x); + }, x => _data.Hiding += x, x => _data.Hiding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16019,9 +14431,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Showing += x, x => _data.Showing -= x); + }, x => _data.Showing += x, x => _data.Showing -= x); } /// @@ -16046,9 +14456,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Hiding += x, x => _data.Hiding -= x); + }, x => _data.Hiding += x, x => _data.Hiding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16056,9 +14464,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Showing += x, x => _data.Showing -= x); + }, x => _data.Showing += x, x => _data.Showing -= x); } /// @@ -16083,9 +14489,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvancedEffectsEnabledChanged += x, x => _data.AdvancedEffectsEnabledChanged -= x); + }, x => _data.AdvancedEffectsEnabledChanged += x, x => _data.AdvancedEffectsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16093,9 +14497,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorValuesChanged += x, x => _data.ColorValuesChanged -= x); + }, x => _data.ColorValuesChanged += x, x => _data.ColorValuesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16103,9 +14505,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextScaleFactorChanged += x, x => _data.TextScaleFactorChanged -= x); + }, x => _data.TextScaleFactorChanged += x, x => _data.TextScaleFactorChanged -= x); } } @@ -16144,9 +14544,7 @@ namespace Windows.UI.ViewManagement.Core { void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OcclusionsChanged += x, x => _data.OcclusionsChanged -= x); + }, x => _data.OcclusionsChanged += x, x => _data.OcclusionsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16154,9 +14552,7 @@ namespace Windows.UI.ViewManagement.Core { void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.XYFocusTransferredToPrimaryView += x, x => _data.XYFocusTransferredToPrimaryView -= x); + }, x => _data.XYFocusTransferredToPrimaryView += x, x => _data.XYFocusTransferredToPrimaryView -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16164,9 +14560,7 @@ namespace Windows.UI.ViewManagement.Core { void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.XYFocusTransferringFromPrimaryView += x, x => _data.XYFocusTransferringFromPrimaryView -= x); + }, x => _data.XYFocusTransferringFromPrimaryView += x, x => _data.XYFocusTransferringFromPrimaryView -= x); } } @@ -16209,9 +14603,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); } /// @@ -16236,9 +14628,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16246,9 +14636,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.UI.WebUI.WebUIView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16256,9 +14644,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16266,9 +14652,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16276,9 +14660,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16286,9 +14668,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16296,9 +14676,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16306,9 +14684,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16316,9 +14692,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16326,9 +14700,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16336,9 +14708,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16346,9 +14716,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16356,9 +14724,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16366,9 +14732,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16376,9 +14740,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16386,9 +14748,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16396,9 +14756,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16406,9 +14764,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16416,9 +14772,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } } @@ -16537,9 +14891,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EnteredBackground += x, x => _data.EnteredBackground -= x); + }, x => _data.EnteredBackground += x, x => _data.EnteredBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16547,9 +14899,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LeavingBackground += x, x => _data.LeavingBackground -= x); + }, x => _data.LeavingBackground += x, x => _data.LeavingBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16557,9 +14907,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Resuming += x, x => _data.Resuming -= x); + }, x => _data.Resuming += x, x => _data.Resuming -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16567,9 +14915,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Suspending += x, x => _data.Suspending -= x); + }, x => _data.Suspending += x, x => _data.Suspending -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16577,9 +14923,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.UnhandledExceptionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); } /// @@ -16604,9 +14948,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -16631,9 +14973,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.BindingFailedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingFailed += x, x => _data.BindingFailed -= x); + }, x => _data.BindingFailed += x, x => _data.BindingFailed -= x); } /// @@ -16658,9 +14998,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -16685,9 +15023,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// @@ -16712,9 +15048,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.FrameworkElement sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActualThemeChanged += x, x => _data.ActualThemeChanged -= x); + }, x => _data.ActualThemeChanged += x, x => _data.ActualThemeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16722,9 +15056,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EffectiveViewportChanged += x, x => _data.EffectiveViewportChanged -= x); + }, x => _data.EffectiveViewportChanged += x, x => _data.EffectiveViewportChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16732,9 +15064,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16742,9 +15072,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16752,9 +15080,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16762,9 +15088,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16772,9 +15096,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16782,9 +15104,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -16809,9 +15129,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -16836,9 +15154,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16846,9 +15162,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16856,9 +15170,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16866,9 +15178,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -16893,9 +15203,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -16920,9 +15228,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -16947,9 +15253,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -16974,9 +15278,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -17001,9 +15303,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -17028,9 +15328,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -17055,9 +15353,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -17082,9 +15378,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17092,9 +15386,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17102,9 +15394,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17112,9 +15402,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BringIntoViewRequested += x, x => _data.BringIntoViewRequested -= x); + }, x => _data.BringIntoViewRequested += x, x => _data.BringIntoViewRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17122,9 +15410,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17132,9 +15418,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContextCanceled += x, x => _data.ContextCanceled -= x); + }, x => _data.ContextCanceled += x, x => _data.ContextCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17142,9 +15426,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContextRequested += x, x => _data.ContextRequested -= x); + }, x => _data.ContextRequested += x, x => _data.ContextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17152,9 +15434,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17162,9 +15442,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); + }, x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17172,9 +15450,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragEnter += x, x => _data.DragEnter -= x); + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17182,9 +15458,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragLeave += x, x => _data.DragLeave -= x); + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17192,9 +15466,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragOver += x, x => _data.DragOver -= x); + }, x => _data.DragOver += x, x => _data.DragOver -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17202,9 +15474,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragStarting += x, x => _data.DragStarting -= x); + }, x => _data.DragStarting += x, x => _data.DragStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17212,9 +15482,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drop += x, x => _data.Drop -= x); + }, x => _data.Drop += x, x => _data.Drop -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17222,9 +15490,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DropCompleted += x, x => _data.DropCompleted -= x); + }, x => _data.DropCompleted += x, x => _data.DropCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17232,9 +15498,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GettingFocus += x, x => _data.GettingFocus -= x); + }, x => _data.GettingFocus += x, x => _data.GettingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17242,9 +15506,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17252,9 +15514,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.HoldingRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Holding += x, x => _data.Holding -= x); + }, x => _data.Holding += x, x => _data.Holding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17262,9 +15522,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17272,9 +15530,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17282,9 +15538,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17292,9 +15546,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17302,9 +15554,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17312,9 +15562,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17322,9 +15570,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17332,9 +15578,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17342,9 +15586,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17352,9 +15594,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NoFocusCandidateFound += x, x => _data.NoFocusCandidateFound -= x); + }, x => _data.NoFocusCandidateFound += x, x => _data.NoFocusCandidateFound -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17362,9 +15602,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerCanceled += x, x => _data.PointerCanceled -= x); + }, x => _data.PointerCanceled += x, x => _data.PointerCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17372,9 +15610,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17382,9 +15618,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17392,9 +15626,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17402,9 +15634,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17412,9 +15642,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17422,9 +15650,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17432,9 +15658,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17442,9 +15666,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17452,9 +15674,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17462,9 +15682,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProcessKeyboardAccelerators += x, x => _data.ProcessKeyboardAccelerators -= x); + }, x => _data.ProcessKeyboardAccelerators += x, x => _data.ProcessKeyboardAccelerators -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17472,9 +15690,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.RightTappedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RightTapped += x, x => _data.RightTapped -= x); + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17482,9 +15698,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.TappedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -17509,9 +15723,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -17536,9 +15748,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17546,9 +15756,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17556,9 +15764,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -17583,9 +15789,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -17610,9 +15814,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -17637,9 +15839,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.WindowActivatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17647,9 +15847,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17657,9 +15855,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.WindowSizeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17667,9 +15863,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.VisibilityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } } @@ -17708,9 +15902,7 @@ namespace Windows.UI.Xaml.Automation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -17753,9 +15945,7 @@ namespace Windows.UI.Xaml.Automation.Peers { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -17780,9 +15970,7 @@ namespace Windows.UI.Xaml.Automation.Peers { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -17821,9 +16009,7 @@ namespace Windows.UI.Xaml.Automation.Provider { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -18162,9 +16348,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18172,9 +16356,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18182,9 +16364,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18192,9 +16372,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opening += x, x => _data.Opening -= x); + }, x => _data.Opening += x, x => _data.Opening -= x); } /// @@ -18219,9 +16397,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18229,9 +16405,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SuggestionChosen += x, x => _data.SuggestionChosen -= x); + }, x => _data.SuggestionChosen += x, x => _data.SuggestionChosen -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18239,9 +16413,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -18266,9 +16438,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18293,9 +16463,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18320,9 +16488,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18347,9 +16513,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs e) => eventHandler((sender, e)); return Handler; - } - - , x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18357,9 +16521,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18367,9 +16529,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DateChanged += x, x => _data.DateChanged -= x); + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18377,9 +16537,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -18404,9 +16562,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18414,9 +16570,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); } /// @@ -18441,9 +16595,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); } /// @@ -18468,9 +16620,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18495,9 +16645,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18505,9 +16653,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18515,9 +16661,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextSubmitted += x, x => _data.TextSubmitted -= x); + }, x => _data.TextSubmitted += x, x => _data.TextSubmitted -= x); } /// @@ -18542,9 +16686,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DynamicOverflowItemsChanging += x, x => _data.DynamicOverflowItemsChanging -= x); + }, x => _data.DynamicOverflowItemsChanging += x, x => _data.DynamicOverflowItemsChanging -= x); } /// @@ -18569,9 +16711,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CloseButtonClick += x, x => _data.CloseButtonClick -= x); + }, x => _data.CloseButtonClick += x, x => _data.CloseButtonClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18579,9 +16719,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18589,9 +16727,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18599,9 +16735,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18609,9 +16743,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrimaryButtonClick += x, x => _data.PrimaryButtonClick -= x); + }, x => _data.PrimaryButtonClick += x, x => _data.PrimaryButtonClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18619,9 +16751,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SecondaryButtonClick += x, x => _data.SecondaryButtonClick -= x); + }, x => _data.SecondaryButtonClick += x, x => _data.SecondaryButtonClick -= x); } /// @@ -18646,9 +16776,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusDisengaged += x, x => _data.FocusDisengaged -= x); + }, x => _data.FocusDisengaged += x, x => _data.FocusDisengaged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18656,9 +16784,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusEngaged += x, x => _data.FocusEngaged -= x); + }, x => _data.FocusEngaged += x, x => _data.FocusEngaged -= x); } /// @@ -18683,9 +16809,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18710,9 +16834,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateChanged += x, x => _data.DateChanged -= x); + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18720,9 +16842,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); } /// @@ -18747,9 +16867,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DatePicked += x, x => _data.DatePicked -= x); + }, x => _data.DatePicked += x, x => _data.DatePicked -= x); } /// @@ -18774,9 +16892,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18801,9 +16917,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18811,9 +16925,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18821,9 +16933,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationFailedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18831,9 +16941,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); } /// @@ -18858,9 +16966,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -18885,9 +16991,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18895,9 +16999,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -18922,9 +17024,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.HubSectionHeaderClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SectionHeaderClick += x, x => _data.SectionHeaderClick -= x); + }, x => _data.SectionHeaderClick += x, x => _data.SectionHeaderClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18932,9 +17032,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SectionsInViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SectionsInViewChanged += x, x => _data.SectionsInViewChanged -= x); + }, x => _data.SectionsInViewChanged += x, x => _data.SectionsInViewChanged -= x); } /// @@ -18959,9 +17057,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18986,9 +17082,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18996,9 +17090,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); } /// @@ -19023,9 +17115,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveToolChanged += x, x => _data.ActiveToolChanged -= x); + }, x => _data.ActiveToolChanged += x, x => _data.ActiveToolChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19033,9 +17123,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EraseAllClicked += x, x => _data.EraseAllClicked -= x); + }, x => _data.EraseAllClicked += x, x => _data.EraseAllClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19043,9 +17131,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InkDrawingAttributesChanged += x, x => _data.InkDrawingAttributesChanged -= x); + }, x => _data.InkDrawingAttributesChanged += x, x => _data.InkDrawingAttributesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19053,9 +17139,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsRulerButtonCheckedChanged += x, x => _data.IsRulerButtonCheckedChanged -= x); + }, x => _data.IsRulerButtonCheckedChanged += x, x => _data.IsRulerButtonCheckedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19063,9 +17147,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsStencilButtonCheckedChanged += x, x => _data.IsStencilButtonCheckedChanged -= x); + }, x => _data.IsStencilButtonCheckedChanged += x, x => _data.IsStencilButtonCheckedChanged -= x); } /// @@ -19090,9 +17172,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19117,9 +17197,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Checked += x, x => _data.Checked -= x); + }, x => _data.Checked += x, x => _data.Checked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19127,9 +17205,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Unchecked += x, x => _data.Unchecked -= x); + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); } /// @@ -19154,9 +17230,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19164,9 +17238,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -19191,9 +17263,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -19218,9 +17288,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); } /// @@ -19245,9 +17313,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); } /// @@ -19272,9 +17338,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19299,9 +17363,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19309,9 +17371,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -19336,9 +17396,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemsPicked += x, x => _data.ItemsPicked -= x); + }, x => _data.ItemsPicked += x, x => _data.ItemsPicked -= x); } /// @@ -19363,9 +17421,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ChoosingGroupHeaderContainer += x, x => _data.ChoosingGroupHeaderContainer -= x); + }, x => _data.ChoosingGroupHeaderContainer += x, x => _data.ChoosingGroupHeaderContainer -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19373,9 +17429,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ChoosingItemContainer += x, x => _data.ChoosingItemContainer -= x); + }, x => _data.ChoosingItemContainer += x, x => _data.ChoosingItemContainer -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19383,9 +17437,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainerContentChanging += x, x => _data.ContainerContentChanging -= x); + }, x => _data.ContainerContentChanging += x, x => _data.ContainerContentChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19393,9 +17445,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19403,9 +17453,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.DragItemsStartingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19413,9 +17461,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ItemClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemClick += x, x => _data.ItemClick -= x); + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); } /// @@ -19440,9 +17486,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19450,9 +17494,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19460,9 +17502,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19470,9 +17510,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Media.TimelineMarkerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MarkerReached += x, x => _data.MarkerReached -= x); + }, x => _data.MarkerReached += x, x => _data.MarkerReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19480,9 +17518,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19490,9 +17526,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19500,9 +17534,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19510,9 +17542,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PartialMediaFailureDetected += x, x => _data.PartialMediaFailureDetected -= x); + }, x => _data.PartialMediaFailureDetected += x, x => _data.PartialMediaFailureDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19520,9 +17550,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Media.RateChangedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RateChanged += x, x => _data.RateChanged -= x); + }, x => _data.RateChanged += x, x => _data.RateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19530,9 +17558,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19540,9 +17566,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); } /// @@ -19567,9 +17591,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailRequested += x, x => _data.ThumbnailRequested -= x); + }, x => _data.ThumbnailRequested += x, x => _data.ThumbnailRequested -= x); } /// @@ -19594,9 +17616,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -19621,9 +17641,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BackRequested += x, x => _data.BackRequested -= x); + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19631,9 +17649,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19641,9 +17657,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19651,9 +17665,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19661,9 +17673,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19671,9 +17681,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19681,9 +17689,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19691,9 +17697,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -19718,9 +17722,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19745,9 +17747,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19755,9 +17755,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19765,9 +17763,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PasswordChanging += x, x => _data.PasswordChanging -= x); + }, x => _data.PasswordChanging += x, x => _data.PasswordChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19775,9 +17771,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paste += x, x => _data.Paste -= x); + }, x => _data.Paste += x, x => _data.Paste -= x); } /// @@ -19802,9 +17796,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19829,9 +17821,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Confirmed += x, x => _data.Confirmed -= x); + }, x => _data.Confirmed += x, x => _data.Confirmed -= x); } /// @@ -19856,9 +17846,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemLoaded += x, x => _data.PivotItemLoaded -= x); + }, x => _data.PivotItemLoaded += x, x => _data.PivotItemLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19866,9 +17854,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemLoading += x, x => _data.PivotItemLoading -= x); + }, x => _data.PivotItemLoading += x, x => _data.PivotItemLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19876,9 +17862,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemUnloaded += x, x => _data.PivotItemUnloaded -= x); + }, x => _data.PivotItemUnloaded += x, x => _data.PivotItemUnloaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19886,9 +17870,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemUnloading += x, x => _data.PivotItemUnloading -= x); + }, x => _data.PivotItemUnloading += x, x => _data.PivotItemUnloading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19896,9 +17878,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -19923,9 +17903,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19933,9 +17911,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -19960,9 +17936,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RatingControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -19987,9 +17961,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20014,9 +17986,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); } /// @@ -20041,9 +18011,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20051,9 +18019,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RefreshStateChanged += x, x => _data.RefreshStateChanged -= x); + }, x => _data.RefreshStateChanged += x, x => _data.RefreshStateChanged -= x); } /// @@ -20078,9 +18044,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20088,9 +18052,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLinkChanged += x, x => _data.ContentLinkChanged -= x); + }, x => _data.ContentLinkChanged += x, x => _data.ContentLinkChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20098,9 +18060,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLinkInvoked += x, x => _data.ContentLinkInvoked -= x); + }, x => _data.ContentLinkInvoked += x, x => _data.ContentLinkInvoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20108,9 +18068,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20118,9 +18076,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20128,9 +18084,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20138,9 +18092,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paste += x, x => _data.Paste -= x); + }, x => _data.Paste += x, x => _data.Paste -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20148,9 +18100,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20158,9 +18108,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20168,9 +18116,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20178,9 +18124,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextChanging += x, x => _data.TextChanging -= x); + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20188,9 +18132,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20198,9 +18140,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20208,9 +18148,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); } /// @@ -20235,9 +18173,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20245,9 +18181,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20255,9 +18189,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -20282,9 +18214,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); } /// @@ -20309,9 +18239,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20336,9 +18264,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AnchorRequested += x, x => _data.AnchorRequested -= x); + }, x => _data.AnchorRequested += x, x => _data.AnchorRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20346,9 +18272,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DirectManipulationCompleted += x, x => _data.DirectManipulationCompleted -= x); + }, x => _data.DirectManipulationCompleted += x, x => _data.DirectManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20356,9 +18280,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DirectManipulationStarted += x, x => _data.DirectManipulationStarted -= x); + }, x => _data.DirectManipulationStarted += x, x => _data.DirectManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20366,9 +18288,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChanged += x, x => _data.ViewChanged -= x); + }, x => _data.ViewChanged += x, x => _data.ViewChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20376,9 +18296,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChanging += x, x => _data.ViewChanging -= x); + }, x => _data.ViewChanging += x, x => _data.ViewChanging -= x); } /// @@ -20403,9 +18321,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrepareForFocusOnKeyboardInput += x, x => _data.PrepareForFocusOnKeyboardInput -= x); + }, x => _data.PrepareForFocusOnKeyboardInput += x, x => _data.PrepareForFocusOnKeyboardInput -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20413,9 +18329,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QueryChanged += x, x => _data.QueryChanged -= x); + }, x => _data.QueryChanged += x, x => _data.QueryChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20423,9 +18337,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20433,9 +18345,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); + }, x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20443,9 +18353,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); + }, x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); } /// @@ -20470,9 +18378,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChangeCompleted += x, x => _data.ViewChangeCompleted -= x); + }, x => _data.ViewChangeCompleted += x, x => _data.ViewChangeCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20480,9 +18386,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChangeStarted += x, x => _data.ViewChangeStarted -= x); + }, x => _data.ViewChangeStarted += x, x => _data.ViewChangeStarted -= x); } /// @@ -20507,9 +18411,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.BackClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackClick += x, x => _data.BackClick -= x); + }, x => _data.BackClick += x, x => _data.BackClick -= x); } /// @@ -20534,9 +18436,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -20561,9 +18461,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20571,9 +18469,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20581,9 +18477,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20591,9 +18485,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); } /// @@ -20618,9 +18510,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20628,9 +18518,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -20655,9 +18543,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompositionScaleChanged += x, x => _data.CompositionScaleChanged -= x); + }, x => _data.CompositionScaleChanged += x, x => _data.CompositionScaleChanged -= x); } /// @@ -20682,9 +18568,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20692,9 +18576,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -20719,9 +18601,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20746,9 +18626,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20756,9 +18634,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20766,9 +18642,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -20793,9 +18667,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BeforeTextChanging += x, x => _data.BeforeTextChanging -= x); + }, x => _data.BeforeTextChanging += x, x => _data.BeforeTextChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20803,9 +18675,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20813,9 +18683,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20823,9 +18691,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20833,9 +18699,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20843,9 +18707,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paste += x, x => _data.Paste -= x); + }, x => _data.Paste += x, x => _data.Paste -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20853,9 +18715,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20863,9 +18723,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20873,9 +18731,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20883,9 +18739,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextChanging += x, x => _data.TextChanging -= x); + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20893,9 +18747,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20903,9 +18755,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20913,9 +18763,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); } /// @@ -20940,9 +18788,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20967,9 +18813,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedTimeChanged += x, x => _data.SelectedTimeChanged -= x); + }, x => _data.SelectedTimeChanged += x, x => _data.SelectedTimeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20977,9 +18821,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TimeChanged += x, x => _data.TimeChanged -= x); + }, x => _data.TimeChanged += x, x => _data.TimeChanged -= x); } /// @@ -21004,9 +18846,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimePicked += x, x => _data.TimePicked -= x); + }, x => _data.TimePicked += x, x => _data.TimePicked -= x); } /// @@ -21031,9 +18871,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsCheckedChanged += x, x => _data.IsCheckedChanged -= x); + }, x => _data.IsCheckedChanged += x, x => _data.IsCheckedChanged -= x); } /// @@ -21058,9 +18896,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -21085,9 +18921,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21095,9 +18929,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -21122,9 +18954,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Collapsed += x, x => _data.Collapsed -= x); + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21132,9 +18962,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21142,9 +18970,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21152,9 +18978,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Expanding += x, x => _data.Expanding -= x); + }, x => _data.Expanding += x, x => _data.Expanding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21162,9 +18986,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); } /// @@ -21189,9 +19011,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21216,9 +19036,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21243,9 +19061,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21253,9 +19069,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21263,9 +19077,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -21290,9 +19102,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CleanUpVirtualizedItemEvent += x, x => _data.CleanUpVirtualizedItemEvent -= x); + }, x => _data.CleanUpVirtualizedItemEvent += x, x => _data.CleanUpVirtualizedItemEvent -= x); } /// @@ -21317,9 +19127,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21327,9 +19135,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21337,9 +19143,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21347,9 +19151,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21357,9 +19159,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21367,9 +19167,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21377,9 +19175,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21387,9 +19183,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21397,9 +19191,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21407,9 +19199,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21417,9 +19207,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.WebViewNavigationFailedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21427,9 +19215,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21437,9 +19223,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21447,9 +19231,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21457,9 +19239,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.NotifyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21467,9 +19247,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeparateProcessLost += x, x => _data.SeparateProcessLost -= x); + }, x => _data.SeparateProcessLost += x, x => _data.SeparateProcessLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21477,9 +19255,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21487,9 +19263,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21497,9 +19271,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21507,9 +19279,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } } @@ -21616,9 +19386,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); } /// @@ -21643,9 +19411,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UriRequested += x, x => _data.UriRequested -= x); + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); } /// @@ -21670,9 +19436,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UriRequested += x, x => _data.UriRequested -= x); + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); } /// @@ -21697,9 +19461,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21724,9 +19486,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActualCameraChanged += x, x => _data.ActualCameraChanged -= x); + }, x => _data.ActualCameraChanged += x, x => _data.ActualCameraChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21734,9 +19494,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActualCameraChanging += x, x => _data.ActualCameraChanging -= x); + }, x => _data.ActualCameraChanging += x, x => _data.ActualCameraChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21744,9 +19502,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CenterChanged += x, x => _data.CenterChanged -= x); + }, x => _data.CenterChanged += x, x => _data.CenterChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21754,9 +19510,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CustomExperienceChanged += x, x => _data.CustomExperienceChanged -= x); + }, x => _data.CustomExperienceChanged += x, x => _data.CustomExperienceChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21764,9 +19518,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadingChanged += x, x => _data.HeadingChanged -= x); + }, x => _data.HeadingChanged += x, x => _data.HeadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21774,9 +19526,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoadingStatusChanged += x, x => _data.LoadingStatusChanged -= x); + }, x => _data.LoadingStatusChanged += x, x => _data.LoadingStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21784,9 +19534,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21794,9 +19542,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapDoubleTapped += x, x => _data.MapDoubleTapped -= x); + }, x => _data.MapDoubleTapped += x, x => _data.MapDoubleTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21804,9 +19550,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21814,9 +19558,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21824,9 +19566,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21834,9 +19574,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapHolding += x, x => _data.MapHolding -= x); + }, x => _data.MapHolding += x, x => _data.MapHolding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21844,9 +19582,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapRightTapped += x, x => _data.MapRightTapped -= x); + }, x => _data.MapRightTapped += x, x => _data.MapRightTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21854,9 +19590,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapTapped += x, x => _data.MapTapped -= x); + }, x => _data.MapTapped += x, x => _data.MapTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21864,9 +19598,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PitchChanged += x, x => _data.PitchChanged -= x); + }, x => _data.PitchChanged += x, x => _data.PitchChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21874,9 +19606,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21884,9 +19614,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TransformOriginChanged += x, x => _data.TransformOriginChanged -= x); + }, x => _data.TransformOriginChanged += x, x => _data.TransformOriginChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21894,9 +19622,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ZoomLevelChanged += x, x => _data.ZoomLevelChanged -= x); + }, x => _data.ZoomLevelChanged += x, x => _data.ZoomLevelChanged -= x); } /// @@ -21921,9 +19647,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21948,9 +19672,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21975,9 +19697,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21985,9 +19705,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21995,9 +19713,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22005,9 +19721,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); } /// @@ -22032,9 +19746,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22059,9 +19771,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22086,9 +19796,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22113,9 +19821,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22140,9 +19846,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22167,9 +19871,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22177,9 +19879,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); } /// @@ -22204,9 +19904,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22231,9 +19929,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22258,9 +19954,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22285,9 +19979,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -22458,9 +20150,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22485,9 +20175,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22512,9 +20200,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22539,9 +20225,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -22566,9 +20250,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22593,9 +20275,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22603,9 +20283,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -22630,9 +20308,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); } /// @@ -22657,9 +20333,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22684,9 +20358,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22711,9 +20383,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22738,9 +20408,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22748,9 +20416,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22758,9 +20424,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22768,9 +20432,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22778,9 +20440,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opening += x, x => _data.Opening -= x); + }, x => _data.Opening += x, x => _data.Opening -= x); } /// @@ -22805,9 +20465,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22832,9 +20490,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22842,9 +20498,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -22869,9 +20523,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22896,9 +20548,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22923,9 +20573,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22950,9 +20598,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -22977,9 +20623,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22987,9 +20631,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -23014,9 +20656,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23041,9 +20681,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23068,9 +20706,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23078,9 +20714,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -23105,9 +20739,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23115,9 +20747,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -23142,9 +20772,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23152,9 +20780,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -23179,9 +20805,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23206,9 +20830,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23233,9 +20855,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -23260,9 +20880,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scroll += x, x => _data.Scroll -= x); + }, x => _data.Scroll += x, x => _data.Scroll -= x); } /// @@ -23287,9 +20905,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -23314,9 +20930,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23341,9 +20955,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23368,9 +20980,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23378,9 +20988,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragDelta += x, x => _data.DragDelta -= x); + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23388,9 +20996,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); } /// @@ -23415,9 +21021,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Checked += x, x => _data.Checked -= x); + }, x => _data.Checked += x, x => _data.Checked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23425,9 +21029,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23435,9 +21037,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unchecked += x, x => _data.Unchecked -= x); + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); } /// @@ -23462,9 +21062,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23489,9 +21087,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -23542,9 +21138,7 @@ namespace Windows.UI.Xaml.Data { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23569,9 +21163,7 @@ namespace Windows.UI.Xaml.Data { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23596,9 +21188,7 @@ namespace Windows.UI.Xaml.Data { void Handler(object sender, object instance) => eventHandler(instance); return Handler; - } - - , x => _data.ElementInstanceChanged += x, x => _data.ElementInstanceChanged -= x); + }, x => _data.ElementInstanceChanged += x, x => _data.ElementInstanceChanged -= x); } /// @@ -23623,9 +21213,7 @@ namespace Windows.UI.Xaml.Data { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23633,9 +21221,7 @@ namespace Windows.UI.Xaml.Data { void Handler(object sender, global::Windows.UI.Xaml.Data.CurrentChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); } } @@ -23690,9 +21276,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23700,9 +21284,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23710,9 +21292,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); } /// @@ -23737,9 +21317,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23764,9 +21342,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -23791,9 +21367,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23801,9 +21375,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23811,9 +21383,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); } /// @@ -23838,9 +21408,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -23891,9 +21459,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23918,9 +21484,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23945,9 +21509,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23955,9 +21517,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -23982,9 +21542,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23992,9 +21550,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CanExecuteRequested += x, x => _data.CanExecuteRequested -= x); + }, x => _data.CanExecuteRequested += x, x => _data.CanExecuteRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24002,9 +21558,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24012,9 +21566,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ExecuteRequested += x, x => _data.ExecuteRequested -= x); + }, x => _data.ExecuteRequested += x, x => _data.ExecuteRequested -= x); } } @@ -24053,9 +21605,7 @@ namespace Windows.UI.Xaml.Interop { void Handler(global::Windows.UI.Xaml.Interop.IBindableObservableVector vector, object e) => eventHandler((vector, e)); return Handler; - } - - , x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); } } @@ -24142,9 +21692,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24169,9 +21717,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24196,9 +21742,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24223,9 +21767,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24250,9 +21792,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24277,9 +21817,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24287,9 +21825,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); } /// @@ -24314,9 +21850,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24341,9 +21875,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); } /// @@ -24368,9 +21900,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24395,9 +21925,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24422,9 +21950,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24449,9 +21975,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24476,9 +22000,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -24553,9 +22075,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24580,9 +22100,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -24607,9 +22125,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24634,9 +22150,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24661,9 +22175,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24688,9 +22200,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24715,9 +22225,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24742,9 +22250,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24769,9 +22275,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24779,9 +22283,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24806,9 +22308,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -24851,9 +22351,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(object sender, global::Windows.UI.Xaml.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24861,9 +22359,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24871,9 +22367,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); } /// @@ -24898,9 +22392,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24908,9 +22400,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); } } @@ -24949,9 +22439,7 @@ namespace Windows.UI.Xaml.Media.Media3D { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -24990,9 +22478,7 @@ namespace Windows.UI.Xaml.Navigation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -25031,9 +22517,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(object sender, global::Windows.UI.Xaml.Printing.AddPagesEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AddPages += x, x => _data.AddPages -= x); + }, x => _data.AddPages += x, x => _data.AddPages -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25041,9 +22525,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25051,9 +22533,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(object sender, global::Windows.UI.Xaml.Printing.GetPreviewPageEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GetPreviewPage += x, x => _data.GetPreviewPage -= x); + }, x => _data.GetPreviewPage += x, x => _data.GetPreviewPage -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25061,9 +22541,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(object sender, global::Windows.UI.Xaml.Printing.PaginateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paginate += x, x => _data.Paginate -= x); + }, x => _data.Paginate += x, x => _data.Paginate -= x); } } @@ -25102,9 +22580,7 @@ namespace Windows.Web.Http.Filters { void Handler(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); } } @@ -25143,9 +22619,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25153,9 +22627,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25163,9 +22635,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25173,9 +22643,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25183,9 +22651,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25193,9 +22659,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25203,9 +22667,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25213,9 +22675,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25223,9 +22683,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25233,9 +22691,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25243,9 +22699,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25253,9 +22707,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25263,9 +22715,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25273,9 +22723,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25283,9 +22731,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25293,9 +22739,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25303,9 +22747,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } } @@ -25348,9 +22790,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyPressed += x, x => _data.AcceleratorKeyPressed -= x); + }, x => _data.AcceleratorKeyPressed += x, x => _data.AcceleratorKeyPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25358,9 +22798,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25368,9 +22806,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25378,9 +22814,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25388,9 +22822,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25398,9 +22830,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25408,9 +22838,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25418,9 +22846,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25428,9 +22854,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25438,9 +22862,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25448,9 +22870,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25458,9 +22878,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MoveFocusRequested += x, x => _data.MoveFocusRequested -= x); + }, x => _data.MoveFocusRequested += x, x => _data.MoveFocusRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25468,9 +22886,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25478,9 +22894,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25488,9 +22902,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25498,9 +22910,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25508,9 +22918,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25518,9 +22926,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25528,9 +22934,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25538,9 +22942,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25548,9 +22950,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } /// @@ -25575,9 +22975,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProcessExited += x, x => _data.ProcessExited -= x); + }, x => _data.ProcessExited += x, x => _data.ProcessExited -= x); } } @@ -25595,9 +22993,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged += x, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged -= x); + }, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged += x, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged -= x); } } @@ -25615,9 +23011,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated += x, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated += x, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25625,9 +23019,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25635,9 +23027,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25645,9 +23035,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25655,9 +23043,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25665,9 +23051,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25675,9 +23059,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected += x, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected += x, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected -= x); } } @@ -25695,9 +23077,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25705,9 +23085,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, global::Windows.ApplicationModel.DataTransfer.ClipboardHistoryChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25715,9 +23093,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25725,9 +23101,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged -= x); } } @@ -25745,9 +23119,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(object sender, global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged += x, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged -= x); + }, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged += x, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged -= x); } } @@ -25765,9 +23137,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded -= x); + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25775,9 +23145,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved -= x); + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25785,9 +23153,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded -= x); + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25795,9 +23161,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved -= x); + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25805,9 +23169,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.Gamepad.GamepadAdded += x, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded -= x); + }, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded += x, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25815,9 +23177,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved += x, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved -= x); + }, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved += x, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25825,9 +23185,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded -= x); + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25835,9 +23193,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved -= x); + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25845,9 +23201,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded -= x); + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25855,9 +23209,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved -= x); + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25865,9 +23217,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded -= x); + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25875,9 +23225,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved -= x); + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved -= x); } } @@ -25895,9 +23243,7 @@ namespace Windows.Gaming.UI { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged += x, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged -= x); + }, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged += x, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25905,9 +23251,7 @@ namespace Windows.Gaming.UI { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.UI.GameBar.VisibilityChanged += x, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged -= x); + }, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged += x, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged -= x); } } @@ -25925,9 +23269,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated -= x); + }, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25935,9 +23277,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25945,9 +23285,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25955,9 +23293,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25965,9 +23301,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25975,9 +23309,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged -= x); } } @@ -25995,9 +23327,7 @@ namespace Windows.Graphics.Holographic { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged += x, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged -= x); + }, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged += x, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged -= x); } } @@ -26015,9 +23345,7 @@ namespace Windows.Media.Core.Preview { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged += x, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged -= x); + }, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged += x, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged -= x); } } @@ -26035,9 +23363,7 @@ namespace Windows.Media.Devices { void Handler(object sender, global::Windows.Media.Devices.DefaultAudioCaptureDeviceChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged -= x); + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26045,9 +23371,7 @@ namespace Windows.Media.Devices { void Handler(object sender, global::Windows.Media.Devices.DefaultAudioRenderDeviceChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged -= x); + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged -= x); } } @@ -26065,9 +23389,7 @@ namespace Windows.Media.Playback { void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground -= x); + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26075,9 +23397,7 @@ namespace Windows.Media.Playback { void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground -= x); + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground -= x); } } @@ -26095,9 +23415,7 @@ namespace Windows.Networking.Connectivity { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged += x, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged -= x); + }, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged += x, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged -= x); } } @@ -26115,9 +23433,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged += x, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged -= x); + }, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged += x, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged -= x); } } @@ -26135,9 +23451,7 @@ namespace Windows.Networking.Proximity { void Handler(object sender, global::Windows.Networking.Proximity.ConnectionRequestedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested += x, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested -= x); + }, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested += x, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26145,9 +23459,7 @@ namespace Windows.Networking.Proximity { void Handler(object sender, global::Windows.Networking.Proximity.TriggeredConnectionStateChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged += x, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged -= x); + }, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged += x, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged -= x); } } @@ -26165,9 +23477,7 @@ namespace Windows.Perception.Spatial { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged += x, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged -= x); + }, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged += x, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged -= x); } } @@ -26185,9 +23495,7 @@ namespace Windows.Phone.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged += x, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged -= x); + }, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged += x, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged -= x); } } @@ -26205,9 +23513,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.BackPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26215,9 +23521,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26225,9 +23529,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26235,9 +23537,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased -= x); } } @@ -26255,9 +23555,7 @@ namespace Windows.Security.Authentication.Identity.Provider { void Handler(object sender, global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged += x, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged -= x); + }, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged += x, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged -= x); } } @@ -26275,9 +23573,7 @@ namespace Windows.System { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased -= x); + }, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26285,9 +23581,7 @@ namespace Windows.System { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased -= x); + }, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26295,9 +23589,7 @@ namespace Windows.System { void Handler(object sender, global::Windows.System.AppMemoryUsageLimitChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging += x, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging -= x); + }, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging += x, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26305,9 +23597,7 @@ namespace Windows.System { void Handler(object sender, global::Windows.System.UserDeviceAssociationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged += x, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged -= x); + }, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged += x, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged -= x); } } @@ -26325,9 +23615,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased -= x); + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26335,9 +23623,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26345,9 +23631,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased -= x); + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26355,9 +23639,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26365,9 +23647,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.BatteryStatusChanged += x, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged -= x); + }, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged += x, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26375,9 +23655,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged += x, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged -= x); + }, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged += x, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26385,9 +23663,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged += x, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged -= x); + }, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged += x, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26395,9 +23671,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged += x, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged -= x); + }, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged += x, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26405,9 +23679,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged += x, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged -= x); + }, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged += x, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged -= x); } } @@ -26425,9 +23697,7 @@ namespace Windows.System.Profile { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged += x, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged -= x); + }, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged += x, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26435,9 +23705,7 @@ namespace Windows.System.Profile { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged += x, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged -= x); + }, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged += x, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26445,9 +23713,7 @@ namespace Windows.System.Profile { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged += x, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged -= x); + }, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged += x, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged -= x); } } @@ -26465,9 +23731,7 @@ namespace Windows.UI.ViewManagement { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged += x, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged -= x); + }, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged += x, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged -= x); } } @@ -26485,9 +23749,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs eventArgs) => eventHandler(eventArgs); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Activated += x, x => global::Windows.UI.WebUI.WebUIApplication.Activated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Activated += x, x => global::Windows.UI.WebUI.WebUIApplication.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26495,9 +23757,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs eventArgs) => eventHandler(eventArgs); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated += x, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated += x, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26505,9 +23765,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.IEnteredBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26515,9 +23773,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.ILeavingBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26525,9 +23781,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.UI.WebUI.IWebUINavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Navigated += x, x => global::Windows.UI.WebUI.WebUIApplication.Navigated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Navigated += x, x => global::Windows.UI.WebUI.WebUIApplication.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26535,9 +23789,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.UI.WebUI.NewWebUIViewCreatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated += x, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated += x, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26545,9 +23797,7 @@ namespace Windows.UI.WebUI { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Resuming += x, x => global::Windows.UI.WebUI.WebUIApplication.Resuming -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Resuming += x, x => global::Windows.UI.WebUI.WebUIApplication.Resuming -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26555,9 +23805,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.ISuspendingEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Suspending += x, x => global::Windows.UI.WebUI.WebUIApplication.Suspending -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Suspending += x, x => global::Windows.UI.WebUI.WebUIApplication.Suspending -= x); } } @@ -26575,9 +23823,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, object args) => eventHandler(args); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged += x, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged -= x); + }, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged += x, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26585,9 +23831,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26595,9 +23839,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerGotFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26605,9 +23847,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26615,9 +23855,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerLostFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus -= x); } } @@ -26635,9 +23873,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, global::Windows.UI.Xaml.Media.RenderedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered -= x); + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26645,9 +23881,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering -= x); + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26655,8 +23889,6 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost -= x); + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.xamarinios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.xamarinios10.approved.txt index 30b92fc..1321c2c 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.xamarinios10.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Uno.UI.1.44.1.xamarinios10.approved.txt @@ -60,9 +60,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -70,9 +68,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UIButtonEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -80,9 +76,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UIButtonEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -90,9 +84,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Presented += x, x => _data.Presented -= x); + }, x => _data.Presented += x, x => _data.Presented -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -100,9 +92,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UIButtonEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillDismiss += x, x => _data.WillDismiss -= x); + }, x => _data.WillDismiss += x, x => _data.WillDismiss -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -110,9 +100,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillPresent += x, x => _data.WillPresent -= x); + }, x => _data.WillPresent += x, x => _data.WillPresent -= x); } /// @@ -137,9 +125,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AllEditingEvents += x, x => _data.AllEditingEvents -= x); + }, x => _data.AllEditingEvents += x, x => _data.AllEditingEvents -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -147,9 +133,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AllEvents += x, x => _data.AllEvents -= x); + }, x => _data.AllEvents += x, x => _data.AllEvents -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -157,9 +141,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AllTouchEvents += x, x => _data.AllTouchEvents -= x); + }, x => _data.AllTouchEvents += x, x => _data.AllTouchEvents -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -167,9 +149,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EditingChanged += x, x => _data.EditingChanged -= x); + }, x => _data.EditingChanged += x, x => _data.EditingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -177,9 +157,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EditingDidBegin += x, x => _data.EditingDidBegin -= x); + }, x => _data.EditingDidBegin += x, x => _data.EditingDidBegin -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -187,9 +165,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EditingDidEnd += x, x => _data.EditingDidEnd -= x); + }, x => _data.EditingDidEnd += x, x => _data.EditingDidEnd -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -197,9 +173,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EditingDidEndOnExit += x, x => _data.EditingDidEndOnExit -= x); + }, x => _data.EditingDidEndOnExit += x, x => _data.EditingDidEndOnExit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -207,9 +181,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PrimaryActionTriggered += x, x => _data.PrimaryActionTriggered -= x); + }, x => _data.PrimaryActionTriggered += x, x => _data.PrimaryActionTriggered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -217,9 +189,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TouchCancel += x, x => _data.TouchCancel -= x); + }, x => _data.TouchCancel += x, x => _data.TouchCancel -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -227,9 +197,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TouchDown += x, x => _data.TouchDown -= x); + }, x => _data.TouchDown += x, x => _data.TouchDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -237,9 +205,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TouchDownRepeat += x, x => _data.TouchDownRepeat -= x); + }, x => _data.TouchDownRepeat += x, x => _data.TouchDownRepeat -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -247,9 +213,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TouchDragEnter += x, x => _data.TouchDragEnter -= x); + }, x => _data.TouchDragEnter += x, x => _data.TouchDragEnter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -257,9 +221,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TouchDragExit += x, x => _data.TouchDragExit -= x); + }, x => _data.TouchDragExit += x, x => _data.TouchDragExit -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -267,9 +229,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TouchDragInside += x, x => _data.TouchDragInside -= x); + }, x => _data.TouchDragInside += x, x => _data.TouchDragInside -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -277,9 +237,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TouchDragOutside += x, x => _data.TouchDragOutside -= x); + }, x => _data.TouchDragOutside += x, x => _data.TouchDragOutside -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -287,9 +245,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TouchUpInside += x, x => _data.TouchUpInside -= x); + }, x => _data.TouchUpInside += x, x => _data.TouchUpInside -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -297,9 +253,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TouchUpOutside += x, x => _data.TouchUpOutside -= x); + }, x => _data.TouchUpOutside += x, x => _data.TouchUpOutside -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -307,9 +261,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -334,9 +286,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DecelerationEnded += x, x => _data.DecelerationEnded -= x); + }, x => _data.DecelerationEnded += x, x => _data.DecelerationEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -344,9 +294,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DecelerationStarted += x, x => _data.DecelerationStarted -= x); + }, x => _data.DecelerationStarted += x, x => _data.DecelerationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -354,9 +302,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DidChangeAdjustedContentInset += x, x => _data.DidChangeAdjustedContentInset -= x); + }, x => _data.DidChangeAdjustedContentInset += x, x => _data.DidChangeAdjustedContentInset -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -364,9 +310,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DidZoom += x, x => _data.DidZoom -= x); + }, x => _data.DidZoom += x, x => _data.DidZoom -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -374,9 +318,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.DraggingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DraggingEnded += x, x => _data.DraggingEnded -= x); + }, x => _data.DraggingEnded += x, x => _data.DraggingEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -384,9 +326,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DraggingStarted += x, x => _data.DraggingStarted -= x); + }, x => _data.DraggingStarted += x, x => _data.DraggingStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -394,9 +334,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollAnimationEnded += x, x => _data.ScrollAnimationEnded -= x); + }, x => _data.ScrollAnimationEnded += x, x => _data.ScrollAnimationEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -404,9 +342,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -414,9 +350,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrolledToTop += x, x => _data.ScrolledToTop -= x); + }, x => _data.ScrolledToTop += x, x => _data.ScrolledToTop -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -424,9 +358,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.WillEndDraggingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillEndDragging += x, x => _data.WillEndDragging -= x); + }, x => _data.WillEndDragging += x, x => _data.WillEndDragging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -434,9 +366,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.ZoomingEndedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ZoomingEnded += x, x => _data.ZoomingEnded -= x); + }, x => _data.ZoomingEnded += x, x => _data.ZoomingEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -444,9 +374,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UIScrollViewZoomingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ZoomingStarted += x, x => _data.ZoomingStarted -= x); + }, x => _data.ZoomingStarted += x, x => _data.ZoomingStarted -= x); } /// @@ -471,9 +399,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BookmarkButtonClicked += x, x => _data.BookmarkButtonClicked -= x); + }, x => _data.BookmarkButtonClicked += x, x => _data.BookmarkButtonClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -481,9 +407,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CancelButtonClicked += x, x => _data.CancelButtonClicked -= x); + }, x => _data.CancelButtonClicked += x, x => _data.CancelButtonClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -491,9 +415,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ListButtonClicked += x, x => _data.ListButtonClicked -= x); + }, x => _data.ListButtonClicked += x, x => _data.ListButtonClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -501,9 +423,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnEditingStarted += x, x => _data.OnEditingStarted -= x); + }, x => _data.OnEditingStarted += x, x => _data.OnEditingStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -511,9 +431,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnEditingStopped += x, x => _data.OnEditingStopped -= x); + }, x => _data.OnEditingStopped += x, x => _data.OnEditingStopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -521,9 +439,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchButtonClicked += x, x => _data.SearchButtonClicked -= x); + }, x => _data.SearchButtonClicked += x, x => _data.SearchButtonClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -531,9 +447,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UISearchBarButtonIndexEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedScopeButtonIndexChanged += x, x => _data.SelectedScopeButtonIndexChanged -= x); + }, x => _data.SelectedScopeButtonIndexChanged += x, x => _data.SelectedScopeButtonIndexChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -541,9 +455,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UISearchBarTextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -568,9 +480,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Ended += x, x => _data.Ended -= x); + }, x => _data.Ended += x, x => _data.Ended -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -578,9 +488,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UITextFieldEditingEndedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EndedWithReason += x, x => _data.EndedWithReason -= x); + }, x => _data.EndedWithReason += x, x => _data.EndedWithReason -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -588,9 +496,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Started += x, x => _data.Started -= x); + }, x => _data.Started += x, x => _data.Started -= x); } /// @@ -615,9 +521,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -625,9 +529,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Ended += x, x => _data.Ended -= x); + }, x => _data.Ended += x, x => _data.Ended -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -635,9 +537,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -645,9 +545,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Started += x, x => _data.Started -= x); + }, x => _data.Started += x, x => _data.Started -= x); } } @@ -686,9 +584,7 @@ namespace Uno.UI.Common { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } } @@ -739,9 +635,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -749,9 +643,7 @@ namespace Uno.UI.Controls { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -776,9 +668,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -786,9 +676,7 @@ namespace Uno.UI.Controls { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -813,9 +701,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -823,9 +709,7 @@ namespace Uno.UI.Controls { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -850,9 +734,7 @@ namespace Uno.UI.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -899,9 +781,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -909,9 +789,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Controls.ItemClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemClick += x, x => _data.ItemClick -= x); + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -919,9 +797,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -929,9 +805,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -939,9 +813,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -949,9 +821,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -959,9 +829,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -969,9 +837,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -996,9 +862,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1023,9 +887,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Controls.ItemClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemClick += x, x => _data.ItemClick -= x); + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1033,9 +895,7 @@ namespace Uno.UI.Controls.Legacy { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } } @@ -1102,9 +962,7 @@ namespace Uno.UI.Views.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1129,9 +987,7 @@ namespace Uno.UI.Views.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1156,9 +1012,7 @@ namespace Uno.UI.Views.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1183,9 +1037,7 @@ namespace Uno.UI.Views.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1210,9 +1062,7 @@ namespace Uno.UI.Views.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1237,9 +1087,7 @@ namespace Uno.UI.Views.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1264,9 +1112,7 @@ namespace Uno.UI.Views.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -1291,9 +1137,7 @@ namespace Uno.UI.Views.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -1332,9 +1176,7 @@ namespace Uno.Xaml { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnNameScopeInitializationComplete += x, x => _data.OnNameScopeInitializationComplete -= x); + }, x => _data.OnNameScopeInitializationComplete += x, x => _data.OnNameScopeInitializationComplete -= x); } } @@ -1373,9 +1215,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageContentGroupStagingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageContentGroupStaging += x, x => _data.PackageContentGroupStaging -= x); + }, x => _data.PackageContentGroupStaging += x, x => _data.PackageContentGroupStaging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1383,9 +1223,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageInstallingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageInstalling += x, x => _data.PackageInstalling -= x); + }, x => _data.PackageInstalling += x, x => _data.PackageInstalling -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1393,9 +1231,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStagingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageStaging += x, x => _data.PackageStaging -= x); + }, x => _data.PackageStaging += x, x => _data.PackageStaging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1403,9 +1239,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1413,9 +1247,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUninstallingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1423,9 +1255,7 @@ namespace Windows.ApplicationModel { void Handler(global::Windows.ApplicationModel.PackageCatalog sender, global::Windows.ApplicationModel.PackageUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); } } @@ -1464,9 +1294,7 @@ namespace Windows.ApplicationModel.Activation { void Handler(global::Windows.ApplicationModel.Activation.SplashScreen sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); } } @@ -1505,9 +1333,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageInstalled += x, x => _data.PackageInstalled -= x); + }, x => _data.PackageInstalled += x, x => _data.PackageInstalled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1515,9 +1341,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); + }, x => _data.PackageStatusChanged += x, x => _data.PackageStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1525,9 +1349,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); + }, x => _data.PackageUninstalling += x, x => _data.PackageUninstalling -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1535,9 +1357,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUpdated += x, x => _data.PackageUpdated -= x); + }, x => _data.PackageUpdated += x, x => _data.PackageUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1545,9 +1365,7 @@ namespace Windows.ApplicationModel.AppExtensions { void Handler(global::Windows.ApplicationModel.AppExtensions.AppExtensionCatalog sender, global::Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); + }, x => _data.PackageUpdating += x, x => _data.PackageUpdating -= x); } } @@ -1590,9 +1408,7 @@ namespace Windows.ApplicationModel.Appointments { void Handler(global::Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } /// @@ -1617,9 +1433,7 @@ namespace Windows.ApplicationModel.Appointments { void Handler(global::Windows.ApplicationModel.Appointments.AppointmentStore sender, global::Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); } } @@ -1658,9 +1472,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CancelMeetingRequested += x, x => _data.CancelMeetingRequested -= x); + }, x => _data.CancelMeetingRequested += x, x => _data.CancelMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1668,9 +1480,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateOrUpdateAppointmentRequested += x, x => _data.CreateOrUpdateAppointmentRequested -= x); + }, x => _data.CreateOrUpdateAppointmentRequested += x, x => _data.CreateOrUpdateAppointmentRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1678,9 +1488,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1688,9 +1496,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1698,9 +1504,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1708,9 +1512,7 @@ namespace Windows.ApplicationModel.Appointments.DataProvider { void Handler(global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection sender, global::Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); } } @@ -1749,9 +1551,7 @@ namespace Windows.ApplicationModel.AppService { void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1759,9 +1559,7 @@ namespace Windows.ApplicationModel.AppService { void Handler(global::Windows.ApplicationModel.AppService.AppServiceConnection sender, global::Windows.ApplicationModel.AppService.AppServiceClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServiceClosed += x, x => _data.ServiceClosed -= x); + }, x => _data.ServiceClosed += x, x => _data.ServiceClosed -= x); } } @@ -1812,9 +1610,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1822,9 +1618,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Progress += x, x => _data.Progress -= x); + }, x => _data.Progress += x, x => _data.Progress -= x); } /// @@ -1849,9 +1643,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BackgroundActivated += x, x => _data.BackgroundActivated -= x); + }, x => _data.BackgroundActivated += x, x => _data.BackgroundActivated -= x); } /// @@ -1876,9 +1668,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); } /// @@ -1903,9 +1693,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1913,9 +1701,7 @@ namespace Windows.ApplicationModel.Background { void Handler(global::Windows.ApplicationModel.Background.BackgroundTaskRegistration sender, global::Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Progress += x, x => _data.Progress -= x); + }, x => _data.Progress += x, x => _data.Progress -= x); } } @@ -1966,9 +1752,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.ChatConversation sender, global::Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteParticipantComposingChanged += x, x => _data.RemoteParticipantComposingChanged -= x); + }, x => _data.RemoteParticipantComposingChanged += x, x => _data.RemoteParticipantComposingChanged -= x); } /// @@ -1993,9 +1777,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageChanged += x, x => _data.MessageChanged -= x); + }, x => _data.MessageChanged += x, x => _data.MessageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2003,9 +1785,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.ChatMessageStore sender, global::Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); } /// @@ -2030,9 +1810,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.RcsEndUserMessageManager sender, global::Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageAvailableChanged += x, x => _data.MessageAvailableChanged -= x); + }, x => _data.MessageAvailableChanged += x, x => _data.MessageAvailableChanged -= x); } /// @@ -2057,9 +1835,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(global::Windows.ApplicationModel.Chat.RcsTransport sender, global::Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServiceKindSupportedChanged += x, x => _data.ServiceKindSupportedChanged -= x); + }, x => _data.ServiceKindSupportedChanged += x, x => _data.ServiceKindSupportedChanged -= x); } } @@ -2110,9 +1886,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactList sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); } /// @@ -2137,9 +1911,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactListSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } /// @@ -2164,9 +1936,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2174,9 +1944,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactPanel sender, global::Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LaunchFullAppRequested += x, x => _data.LaunchFullAppRequested -= x); + }, x => _data.LaunchFullAppRequested += x, x => _data.LaunchFullAppRequested -= x); } /// @@ -2201,9 +1969,7 @@ namespace Windows.ApplicationModel.Contacts { void Handler(global::Windows.ApplicationModel.Contacts.ContactStore sender, global::Windows.ApplicationModel.Contacts.ContactChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContactChanged += x, x => _data.ContactChanged -= x); + }, x => _data.ContactChanged += x, x => _data.ContactChanged -= x); } } @@ -2242,9 +2008,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateOrUpdateContactRequested += x, x => _data.CreateOrUpdateContactRequested -= x); + }, x => _data.CreateOrUpdateContactRequested += x, x => _data.CreateOrUpdateContactRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2252,9 +2016,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeleteContactRequested += x, x => _data.DeleteContactRequested -= x); + }, x => _data.DeleteContactRequested += x, x => _data.DeleteContactRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2262,9 +2024,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2272,9 +2032,7 @@ namespace Windows.ApplicationModel.Contacts.DataProvider { void Handler(global::Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection sender, global::Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); } } @@ -2313,9 +2071,7 @@ namespace Windows.ApplicationModel.Contacts.Provider { void Handler(global::Windows.ApplicationModel.Contacts.Provider.ContactPickerUI sender, global::Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContactRemoved += x, x => _data.ContactRemoved -= x); + }, x => _data.ContactRemoved += x, x => _data.ContactRemoved -= x); } } @@ -2362,9 +2118,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2372,9 +2126,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationView sender, global::Windows.ApplicationModel.Core.HostedViewClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HostedViewClosing += x, x => _data.HostedViewClosing -= x); + }, x => _data.HostedViewClosing += x, x => _data.HostedViewClosing -= x); } /// @@ -2399,9 +2151,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); + }, x => _data.IsVisibleChanged += x, x => _data.IsVisibleChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2409,9 +2159,7 @@ namespace Windows.ApplicationModel.Core { void Handler(global::Windows.ApplicationModel.Core.CoreApplicationViewTitleBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LayoutMetricsChanged += x, x => _data.LayoutMetricsChanged -= x); + }, x => _data.LayoutMetricsChanged += x, x => _data.LayoutMetricsChanged -= x); } /// @@ -2436,9 +2184,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UnhandledErrorDetected += x, x => _data.UnhandledErrorDetected -= x); + }, x => _data.UnhandledErrorDetected += x, x => _data.UnhandledErrorDetected -= x); } } @@ -2481,9 +2227,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2491,9 +2235,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); + }, x => _data.OperationCompleted += x, x => _data.OperationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2501,9 +2243,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataPackage sender, global::Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShareCompleted += x, x => _data.ShareCompleted -= x); + }, x => _data.ShareCompleted += x, x => _data.ShareCompleted -= x); } /// @@ -2528,9 +2268,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataRequested += x, x => _data.DataRequested -= x); + }, x => _data.DataRequested += x, x => _data.DataRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2538,9 +2276,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShareProvidersRequested += x, x => _data.ShareProvidersRequested -= x); + }, x => _data.ShareProvidersRequested += x, x => _data.ShareProvidersRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2548,9 +2284,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(global::Windows.ApplicationModel.DataTransfer.DataTransferManager sender, global::Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetApplicationChosen += x, x => _data.TargetApplicationChosen -= x); + }, x => _data.TargetApplicationChosen += x, x => _data.TargetApplicationChosen -= x); } } @@ -2589,9 +2323,7 @@ namespace Windows.ApplicationModel.DataTransfer.DragDrop.Core { void Handler(global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager sender, global::Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetRequested += x, x => _data.TargetRequested -= x); + }, x => _data.TargetRequested += x, x => _data.TargetRequested -= x); } } @@ -2634,9 +2366,7 @@ namespace Windows.ApplicationModel.Email { void Handler(global::Windows.ApplicationModel.Email.EmailMailbox sender, global::Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MailboxChanged += x, x => _data.MailboxChanged -= x); + }, x => _data.MailboxChanged += x, x => _data.MailboxChanged -= x); } /// @@ -2661,9 +2391,7 @@ namespace Windows.ApplicationModel.Email { void Handler(global::Windows.ApplicationModel.Email.EmailMailboxSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } } @@ -2702,9 +2430,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateFolderRequested += x, x => _data.CreateFolderRequested -= x); + }, x => _data.CreateFolderRequested += x, x => _data.CreateFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2712,9 +2438,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeleteFolderRequested += x, x => _data.DeleteFolderRequested -= x); + }, x => _data.DeleteFolderRequested += x, x => _data.DeleteFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2722,9 +2446,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadAttachmentRequested += x, x => _data.DownloadAttachmentRequested -= x); + }, x => _data.DownloadAttachmentRequested += x, x => _data.DownloadAttachmentRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2732,9 +2454,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadMessageRequested += x, x => _data.DownloadMessageRequested -= x); + }, x => _data.DownloadMessageRequested += x, x => _data.DownloadMessageRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2742,9 +2462,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EmptyFolderRequested += x, x => _data.EmptyFolderRequested -= x); + }, x => _data.EmptyFolderRequested += x, x => _data.EmptyFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2752,9 +2470,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); + }, x => _data.ForwardMeetingRequested += x, x => _data.ForwardMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2762,9 +2478,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GetAutoReplySettingsRequested += x, x => _data.GetAutoReplySettingsRequested -= x); + }, x => _data.GetAutoReplySettingsRequested += x, x => _data.GetAutoReplySettingsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2772,9 +2486,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MailboxSyncRequested += x, x => _data.MailboxSyncRequested -= x); + }, x => _data.MailboxSyncRequested += x, x => _data.MailboxSyncRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2782,9 +2494,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MoveFolderRequested += x, x => _data.MoveFolderRequested -= x); + }, x => _data.MoveFolderRequested += x, x => _data.MoveFolderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2792,9 +2502,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); + }, x => _data.ProposeNewTimeForMeetingRequested += x, x => _data.ProposeNewTimeForMeetingRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2802,9 +2510,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResolveRecipientsRequested += x, x => _data.ResolveRecipientsRequested -= x); + }, x => _data.ResolveRecipientsRequested += x, x => _data.ResolveRecipientsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2812,9 +2518,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); + }, x => _data.ServerSearchReadBatchRequested += x, x => _data.ServerSearchReadBatchRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2822,9 +2526,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetAutoReplySettingsRequested += x, x => _data.SetAutoReplySettingsRequested -= x); + }, x => _data.SetAutoReplySettingsRequested += x, x => _data.SetAutoReplySettingsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2832,9 +2534,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); + }, x => _data.UpdateMeetingResponseRequested += x, x => _data.UpdateMeetingResponseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2842,9 +2542,7 @@ namespace Windows.ApplicationModel.Email.DataProvider { void Handler(global::Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection sender, global::Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValidateCertificatesRequested += x, x => _data.ValidateCertificatesRequested -= x); + }, x => _data.ValidateCertificatesRequested += x, x => _data.ValidateCertificatesRequested -= x); } } @@ -2883,9 +2581,7 @@ namespace Windows.ApplicationModel.ExtendedExecution { void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionRevokedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Revoked += x, x => _data.Revoked -= x); + }, x => _data.Revoked += x, x => _data.Revoked -= x); } } @@ -2924,9 +2620,7 @@ namespace Windows.ApplicationModel.ExtendedExecution.Foreground { void Handler(object sender, global::Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundRevokedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Revoked += x, x => _data.Revoked -= x); + }, x => _data.Revoked += x, x => _data.Revoked -= x); } } @@ -2969,9 +2663,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockApplicationHost sender, global::Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Unlocking += x, x => _data.Unlocking -= x); + }, x => _data.Unlocking += x, x => _data.Unlocking -= x); } /// @@ -2996,9 +2688,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AlarmIconChanged += x, x => _data.AlarmIconChanged -= x); + }, x => _data.AlarmIconChanged += x, x => _data.AlarmIconChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3006,9 +2696,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BadgesChanged += x, x => _data.BadgesChanged -= x); + }, x => _data.BadgesChanged += x, x => _data.BadgesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3016,9 +2704,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DetailTextChanged += x, x => _data.DetailTextChanged -= x); + }, x => _data.DetailTextChanged += x, x => _data.DetailTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3026,9 +2712,7 @@ namespace Windows.ApplicationModel.LockScreen { void Handler(global::Windows.ApplicationModel.LockScreen.LockScreenInfo sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LockScreenImageChanged += x, x => _data.LockScreenImageChanged -= x); + }, x => _data.LockScreenImageChanged += x, x => _data.LockScreenImageChanged -= x); } } @@ -3067,9 +2751,7 @@ namespace Windows.ApplicationModel.Resources.Core { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } } @@ -3108,9 +2790,7 @@ namespace Windows.ApplicationModel.Store { void Handler() => eventHandler(global::System.Reactive.Unit.Default); return Handler; - } - - , x => _data.LicenseChanged += x, x => _data.LicenseChanged -= x); + }, x => _data.LicenseChanged += x, x => _data.LicenseChanged -= x); } } @@ -3153,9 +2833,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3163,9 +2841,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -3190,9 +2866,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemCompleted += x, x => _data.ItemCompleted -= x); + }, x => _data.ItemCompleted += x, x => _data.ItemCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3200,9 +2874,7 @@ namespace Windows.ApplicationModel.Store.Preview.InstallControl { void Handler(global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager sender, global::Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemStatusChanged += x, x => _data.ItemStatusChanged -= x); + }, x => _data.ItemStatusChanged += x, x => _data.ItemStatusChanged -= x); } } @@ -3241,9 +2913,7 @@ namespace Windows.ApplicationModel.UserActivities { void Handler(global::Windows.ApplicationModel.UserActivities.UserActivityRequestManager sender, global::Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserActivityRequested += x, x => _data.UserActivityRequested -= x); + }, x => _data.UserActivityRequested += x, x => _data.UserActivityRequested -= x); } } @@ -3282,9 +2952,7 @@ namespace Windows.ApplicationModel.UserDataAccounts { void Handler(global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore sender, global::Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StoreChanged += x, x => _data.StoreChanged -= x); + }, x => _data.StoreChanged += x, x => _data.StoreChanged -= x); } } @@ -3323,9 +2991,7 @@ namespace Windows.ApplicationModel.UserDataTasks { void Handler(global::Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); + }, x => _data.SyncStatusChanged += x, x => _data.SyncStatusChanged -= x); } } @@ -3364,9 +3030,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompleteTaskRequested += x, x => _data.CompleteTaskRequested -= x); + }, x => _data.CompleteTaskRequested += x, x => _data.CompleteTaskRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3374,9 +3038,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CreateOrUpdateTaskRequested += x, x => _data.CreateOrUpdateTaskRequested -= x); + }, x => _data.CreateOrUpdateTaskRequested += x, x => _data.CreateOrUpdateTaskRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3384,9 +3046,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeleteTaskRequested += x, x => _data.DeleteTaskRequested -= x); + }, x => _data.DeleteTaskRequested += x, x => _data.DeleteTaskRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3394,9 +3054,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SkipOccurrenceRequested += x, x => _data.SkipOccurrenceRequested -= x); + }, x => _data.SkipOccurrenceRequested += x, x => _data.SkipOccurrenceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3404,9 +3062,7 @@ namespace Windows.ApplicationModel.UserDataTasks.DataProvider { void Handler(global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection sender, global::Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SyncRequested += x, x => _data.SyncRequested -= x); + }, x => _data.SyncRequested += x, x => _data.SyncRequested -= x); } } @@ -3445,9 +3101,7 @@ namespace Windows.ApplicationModel.VoiceCommands { void Handler(global::Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection sender, global::Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VoiceCommandCompleted += x, x => _data.VoiceCommandCompleted -= x); + }, x => _data.VoiceCommandCompleted += x, x => _data.VoiceCommandCompleted -= x); } } @@ -3486,9 +3140,7 @@ namespace Windows.ApplicationModel.Wallet.System { void Handler(global::Windows.ApplicationModel.Wallet.System.WalletItemSystemStore sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); } } @@ -3535,9 +3187,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAcceptSessionJoinerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceptSessionJoinerRequested += x, x => _data.AcceptSessionJoinerRequested -= x); + }, x => _data.AcceptSessionJoinerRequested += x, x => _data.AcceptSessionJoinerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3545,9 +3195,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynAuthenticationCompleteEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AuthenticationComplete += x, x => _data.AuthenticationComplete -= x); + }, x => _data.AuthenticationComplete += x, x => _data.AuthenticationComplete -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3555,9 +3203,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CredentialsRequested += x, x => _data.CredentialsRequested -= x); + }, x => _data.CredentialsRequested += x, x => _data.CredentialsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3565,9 +3211,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynCredentialsVerificationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CredentialsVerificationRequested += x, x => _data.CredentialsVerificationRequested -= x); + }, x => _data.CredentialsVerificationRequested += x, x => _data.CredentialsVerificationRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3575,9 +3219,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynSessionJoinedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionJoined += x, x => _data.SessionJoined -= x); + }, x => _data.SessionJoined += x, x => _data.SessionJoined -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3585,9 +3227,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusAttachment sender, global::Windows.Devices.AllJoyn.AllJoynBusAttachmentStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -3612,9 +3252,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynBusObject sender, global::Windows.Devices.AllJoyn.AllJoynBusObjectStoppedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -3639,9 +3277,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionLostEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Lost += x, x => _data.Lost -= x); + }, x => _data.Lost += x, x => _data.Lost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3649,9 +3285,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MemberAdded += x, x => _data.MemberAdded -= x); + }, x => _data.MemberAdded += x, x => _data.MemberAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3659,9 +3293,7 @@ namespace Windows.Devices.AllJoyn { void Handler(global::Windows.Devices.AllJoyn.AllJoynSession sender, global::Windows.Devices.AllJoyn.AllJoynSessionMemberRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MemberRemoved += x, x => _data.MemberRemoved -= x); + }, x => _data.MemberRemoved += x, x => _data.MemberRemoved -= x); } } @@ -3704,9 +3336,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3714,9 +3344,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NameChanged += x, x => _data.NameChanged -= x); + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3724,9 +3352,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SdpRecordsChanged += x, x => _data.SdpRecordsChanged -= x); + }, x => _data.SdpRecordsChanged += x, x => _data.SdpRecordsChanged -= x); } /// @@ -3751,9 +3377,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3761,9 +3385,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GattServicesChanged += x, x => _data.GattServicesChanged -= x); + }, x => _data.GattServicesChanged += x, x => _data.GattServicesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3771,9 +3393,7 @@ namespace Windows.Devices.Bluetooth { void Handler(global::Windows.Devices.Bluetooth.BluetoothLEDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NameChanged += x, x => _data.NameChanged -= x); + }, x => _data.NameChanged += x, x => _data.NameChanged -= x); } } @@ -3816,9 +3436,7 @@ namespace Windows.Devices.Bluetooth.Advertisement { void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -3843,9 +3461,7 @@ namespace Windows.Devices.Bluetooth.Advertisement { void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Received += x, x => _data.Received -= x); + }, x => _data.Received += x, x => _data.Received -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3853,9 +3469,7 @@ namespace Windows.Devices.Bluetooth.Advertisement { void Handler(global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher sender, global::Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -3922,9 +3536,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -3949,9 +3561,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3959,9 +3569,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SubscribedClientsChanged += x, x => _data.SubscribedClientsChanged -= x); + }, x => _data.SubscribedClientsChanged += x, x => _data.SubscribedClientsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3969,9 +3577,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); } /// @@ -3996,9 +3602,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadRequested += x, x => _data.ReadRequested -= x); + }, x => _data.ReadRequested += x, x => _data.ReadRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4006,9 +3610,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WriteRequested += x, x => _data.WriteRequested -= x); + }, x => _data.WriteRequested += x, x => _data.WriteRequested -= x); } /// @@ -4033,9 +3635,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -4060,9 +3660,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); } /// @@ -4087,9 +3685,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MaxPduSizeChanged += x, x => _data.MaxPduSizeChanged -= x); + }, x => _data.MaxPduSizeChanged += x, x => _data.MaxPduSizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4097,9 +3693,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); } /// @@ -4124,9 +3718,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MaxNotificationSizeChanged += x, x => _data.MaxNotificationSizeChanged -= x); + }, x => _data.MaxNotificationSizeChanged += x, x => _data.MaxNotificationSizeChanged -= x); } /// @@ -4151,9 +3743,7 @@ namespace Windows.Devices.Bluetooth.GenericAttributeProfile { void Handler(global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest sender, global::Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -4192,9 +3782,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4202,9 +3790,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Disabled += x, x => _data.Disabled -= x); + }, x => _data.Disabled += x, x => _data.Disabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4212,9 +3798,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Enabled += x, x => _data.Enabled -= x); + }, x => _data.Enabled += x, x => _data.Enabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4222,9 +3806,7 @@ namespace Windows.Devices.Display.Core { void Handler(global::Windows.Devices.Display.Core.DisplayManager sender, global::Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PathsFailedOrInvalidated += x, x => _data.PathsFailedOrInvalidated -= x); + }, x => _data.PathsFailedOrInvalidated += x, x => _data.PathsFailedOrInvalidated -= x); } } @@ -4275,9 +3857,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceAccessInformation sender, global::Windows.Devices.Enumeration.DeviceAccessChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessChanged += x, x => _data.AccessChanged -= x); + }, x => _data.AccessChanged += x, x => _data.AccessChanged -= x); } /// @@ -4302,9 +3882,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceInformationCustomPairing sender, global::Windows.Devices.Enumeration.DevicePairingRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PairingRequested += x, x => _data.PairingRequested -= x); + }, x => _data.PairingRequested += x, x => _data.PairingRequested -= x); } /// @@ -4329,9 +3907,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DevicePickerDismissed += x, x => _data.DevicePickerDismissed -= x); + }, x => _data.DevicePickerDismissed += x, x => _data.DevicePickerDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4339,9 +3915,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeviceSelected += x, x => _data.DeviceSelected -= x); + }, x => _data.DeviceSelected += x, x => _data.DeviceSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4349,9 +3923,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DevicePicker sender, global::Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); } /// @@ -4376,9 +3948,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4386,9 +3956,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4396,9 +3964,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4406,9 +3972,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4416,9 +3980,7 @@ namespace Windows.Devices.Enumeration { void Handler(global::Windows.Devices.Enumeration.DeviceWatcher sender, global::Windows.Devices.Enumeration.DeviceInformationUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -4457,9 +4019,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObject args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4467,9 +4027,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4477,9 +4035,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4487,9 +4043,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4497,9 +4051,7 @@ namespace Windows.Devices.Enumeration.Pnp { void Handler(global::Windows.Devices.Enumeration.Pnp.PnpObjectWatcher sender, global::Windows.Devices.Enumeration.Pnp.PnpObjectUpdate args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -4542,9 +4094,7 @@ namespace Windows.Devices.Geolocation { void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.PositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4552,9 +4102,7 @@ namespace Windows.Devices.Geolocation { void Handler(global::Windows.Devices.Geolocation.Geolocator sender, global::Windows.Devices.Geolocation.StatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -4579,9 +4127,7 @@ namespace Windows.Devices.Geolocation { void Handler(global::Windows.Devices.Geolocation.GeovisitMonitor sender, global::Windows.Devices.Geolocation.GeovisitStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisitStateChanged += x, x => _data.VisitStateChanged -= x); + }, x => _data.VisitStateChanged += x, x => _data.VisitStateChanged -= x); } } @@ -4620,9 +4166,7 @@ namespace Windows.Devices.Geolocation.Geofencing { void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GeofenceStateChanged += x, x => _data.GeofenceStateChanged -= x); + }, x => _data.GeofenceStateChanged += x, x => _data.GeofenceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4630,9 +4174,7 @@ namespace Windows.Devices.Geolocation.Geofencing { void Handler(global::Windows.Devices.Geolocation.Geofencing.GeofenceMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } } @@ -4671,9 +4213,7 @@ namespace Windows.Devices.HumanInterfaceDevice { void Handler(global::Windows.Devices.HumanInterfaceDevice.HidDevice sender, global::Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputReportReceived += x, x => _data.InputReportReceived -= x); + }, x => _data.InputReportReceived += x, x => _data.InputReportReceived -= x); } } @@ -4712,9 +4252,7 @@ namespace Windows.Devices.Input { void Handler(global::Windows.Devices.Input.MouseDevice sender, global::Windows.Devices.Input.MouseEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MouseMoved += x, x => _data.MouseMoved -= x); + }, x => _data.MouseMoved += x, x => _data.MouseMoved -= x); } } @@ -4757,9 +4295,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4767,9 +4303,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4777,9 +4311,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4787,9 +4319,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeDeviceWatcherPreview sender, global::Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -4814,9 +4344,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GazeEntered += x, x => _data.GazeEntered -= x); + }, x => _data.GazeEntered += x, x => _data.GazeEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4824,9 +4352,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GazeExited += x, x => _data.GazeExited -= x); + }, x => _data.GazeExited += x, x => _data.GazeExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4834,9 +4360,7 @@ namespace Windows.Devices.Input.Preview { void Handler(global::Windows.Devices.Input.Preview.GazeInputSourcePreview sender, global::Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GazeMoved += x, x => _data.GazeMoved -= x); + }, x => _data.GazeMoved += x, x => _data.GazeMoved -= x); } } @@ -4875,9 +4399,7 @@ namespace Windows.Devices.Lights { void Handler(global::Windows.Devices.Lights.Lamp sender, global::Windows.Devices.Lights.LampAvailabilityChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); + }, x => _data.AvailabilityChanged += x, x => _data.AvailabilityChanged -= x); } } @@ -4920,9 +4442,7 @@ namespace Windows.Devices.Lights.Effects { void Handler(global::Windows.Devices.Lights.Effects.LampArrayBitmapEffect sender, global::Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); } /// @@ -4947,9 +4467,7 @@ namespace Windows.Devices.Lights.Effects { void Handler(global::Windows.Devices.Lights.Effects.LampArrayCustomEffect sender, global::Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateRequested += x, x => _data.UpdateRequested -= x); + }, x => _data.UpdateRequested += x, x => _data.UpdateRequested -= x); } } @@ -4988,9 +4506,7 @@ namespace Windows.Devices.Midi { void Handler(global::Windows.Devices.Midi.MidiInPort sender, global::Windows.Devices.Midi.MidiMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } } @@ -5065,9 +4581,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameReader sender, global::Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -5092,9 +4606,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5102,9 +4614,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5112,9 +4622,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5122,9 +4630,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5132,9 +4638,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); } /// @@ -5159,9 +4663,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5169,9 +4671,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5179,9 +4679,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5189,9 +4687,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionColorFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -5216,9 +4712,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionControlSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ControlLost += x, x => _data.ControlLost -= x); + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); } /// @@ -5243,9 +4737,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameReader sender, global::Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -5270,9 +4762,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5280,9 +4770,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5290,9 +4778,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5300,9 +4786,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5310,9 +4794,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); } /// @@ -5337,9 +4819,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5347,9 +4827,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5357,9 +4835,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5367,9 +4843,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -5394,9 +4868,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameReader sender, global::Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -5421,9 +4893,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); + }, x => _data.ActiveChanged += x, x => _data.ActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5431,9 +4901,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); + }, x => _data.AvailableChanged += x, x => _data.AvailableChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5441,9 +4909,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); + }, x => _data.CameraIntrinsicsChanged += x, x => _data.CameraIntrinsicsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5451,9 +4917,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, global::Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); + }, x => _data.PropertiesChanged += x, x => _data.PropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5461,9 +4925,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); + }, x => _data.VideoProfileChanged += x, x => _data.VideoProfileChanged -= x); } /// @@ -5488,9 +4950,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5498,9 +4958,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceAdded += x, x => _data.SourceAdded -= x); + }, x => _data.SourceAdded += x, x => _data.SourceAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5508,9 +4966,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, global::Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); + }, x => _data.SourceRemoved += x, x => _data.SourceRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5518,9 +4974,7 @@ namespace Windows.Devices.Perception { void Handler(global::Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -5599,9 +5053,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.BarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -5626,9 +5078,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawer sender, global::Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -5653,9 +5103,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawerCloseAlarm sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AlarmTimeoutExpired += x, x => _data.AlarmTimeoutExpired -= x); + }, x => _data.AlarmTimeoutExpired += x, x => _data.AlarmTimeoutExpired -= x); } /// @@ -5680,9 +5128,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); + }, x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5690,9 +5136,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.CashDrawerEventSource sender, global::Windows.Devices.PointOfService.CashDrawerOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); + }, x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); } /// @@ -5717,9 +5161,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5727,9 +5169,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5737,9 +5177,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5747,9 +5185,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedBarcodeScanner sender, global::Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ImagePreviewReceived += x, x => _data.ImagePreviewReceived -= x); + }, x => _data.ImagePreviewReceived += x, x => _data.ImagePreviewReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5757,9 +5193,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5767,9 +5201,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); return Handler; - } - - , x => _data.TriggerPressed += x, x => _data.TriggerPressed -= x); + }, x => _data.TriggerPressed += x, x => _data.TriggerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5777,9 +5209,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedBarcodeScanner e) => eventHandler(e); return Handler; - } - - , x => _data.TriggerReleased += x, x => _data.TriggerReleased -= x); + }, x => _data.TriggerReleased += x, x => _data.TriggerReleased -= x); } /// @@ -5804,9 +5234,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, global::Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5814,9 +5242,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedCashDrawer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); } /// @@ -5841,9 +5267,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5851,9 +5275,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5861,9 +5283,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedLineDisplay sender, global::Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -5888,9 +5308,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AamvaCardDataReceived += x, x => _data.AamvaCardDataReceived -= x); + }, x => _data.AamvaCardDataReceived += x, x => _data.AamvaCardDataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5898,9 +5316,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BankCardDataReceived += x, x => _data.BankCardDataReceived -= x); + }, x => _data.BankCardDataReceived += x, x => _data.BankCardDataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5908,9 +5324,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5918,9 +5332,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5928,9 +5340,7 @@ namespace Windows.Devices.PointOfService { void Handler(object sender, global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader e) => eventHandler(e); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5938,9 +5348,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedMagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VendorSpecificDataReceived += x, x => _data.VendorSpecificDataReceived -= x); + }, x => _data.VendorSpecificDataReceived += x, x => _data.VendorSpecificDataReceived -= x); } /// @@ -5965,9 +5373,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5975,9 +5381,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.ClaimedPosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); + }, x => _data.ReleaseDeviceRequested += x, x => _data.ReleaseDeviceRequested -= x); } /// @@ -6002,9 +5406,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.MagneticStripeReader sender, global::Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } /// @@ -6029,9 +5431,7 @@ namespace Windows.Devices.PointOfService { void Handler(global::Windows.Devices.PointOfService.PosPrinter sender, global::Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); + }, x => _data.StatusUpdated += x, x => _data.StatusUpdated -= x); } } @@ -6074,9 +5474,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -6101,9 +5499,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisableScannerRequested += x, x => _data.DisableScannerRequested -= x); + }, x => _data.DisableScannerRequested += x, x => _data.DisableScannerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6111,9 +5507,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnableScannerRequested += x, x => _data.EnableScannerRequested -= x); + }, x => _data.EnableScannerRequested += x, x => _data.EnableScannerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6121,9 +5515,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GetBarcodeSymbologyAttributesRequested += x, x => _data.GetBarcodeSymbologyAttributesRequested -= x); + }, x => _data.GetBarcodeSymbologyAttributesRequested += x, x => _data.GetBarcodeSymbologyAttributesRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6131,9 +5523,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HideVideoPreviewRequested += x, x => _data.HideVideoPreviewRequested -= x); + }, x => _data.HideVideoPreviewRequested += x, x => _data.HideVideoPreviewRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6141,9 +5531,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetActiveSymbologiesRequested += x, x => _data.SetActiveSymbologiesRequested -= x); + }, x => _data.SetActiveSymbologiesRequested += x, x => _data.SetActiveSymbologiesRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6151,9 +5539,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetBarcodeSymbologyAttributesRequested += x, x => _data.SetBarcodeSymbologyAttributesRequested -= x); + }, x => _data.SetBarcodeSymbologyAttributesRequested += x, x => _data.SetBarcodeSymbologyAttributesRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6161,9 +5547,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StartSoftwareTriggerRequested += x, x => _data.StartSoftwareTriggerRequested -= x); + }, x => _data.StartSoftwareTriggerRequested += x, x => _data.StartSoftwareTriggerRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6171,9 +5555,7 @@ namespace Windows.Devices.PointOfService.Provider { void Handler(global::Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection sender, global::Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StopSoftwareTriggerRequested += x, x => _data.StopSoftwareTriggerRequested -= x); + }, x => _data.StopSoftwareTriggerRequested += x, x => _data.StopSoftwareTriggerRequested -= x); } } @@ -6212,9 +5594,7 @@ namespace Windows.Devices.Power { void Handler(global::Windows.Devices.Power.Battery sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReportUpdated += x, x => _data.ReportUpdated -= x); + }, x => _data.ReportUpdated += x, x => _data.ReportUpdated -= x); } } @@ -6253,9 +5633,7 @@ namespace Windows.Devices.Printers.Extensions { void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrinterChanged += x, x => _data.PrinterChanged -= x); + }, x => _data.PrinterChanged += x, x => _data.PrinterChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6263,9 +5641,7 @@ namespace Windows.Devices.Printers.Extensions { void Handler(global::Windows.Devices.Printers.Extensions.Print3DWorkflow sender, global::Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrintRequested += x, x => _data.PrintRequested -= x); + }, x => _data.PrintRequested += x, x => _data.PrintRequested -= x); } } @@ -6304,9 +5680,7 @@ namespace Windows.Devices.Radios { void Handler(global::Windows.Devices.Radios.Radio sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -6397,9 +5771,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6407,9 +5779,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Accelerometer sender, global::Windows.Devices.Sensors.AccelerometerShakenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Shaken += x, x => _data.Shaken -= x); + }, x => _data.Shaken += x, x => _data.Shaken -= x); } /// @@ -6434,9 +5804,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.ActivitySensor sender, global::Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -6461,9 +5829,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Altimeter sender, global::Windows.Devices.Sensors.AltimeterReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -6488,9 +5854,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Barometer sender, global::Windows.Devices.Sensors.BarometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -6515,9 +5879,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Compass sender, global::Windows.Devices.Sensors.CompassReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -6542,9 +5904,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Gyrometer sender, global::Windows.Devices.Sensors.GyrometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -6569,9 +5929,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.HingeAngleSensor sender, global::Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -6596,9 +5954,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Inclinometer sender, global::Windows.Devices.Sensors.InclinometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -6623,9 +5979,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.LightSensor sender, global::Windows.Devices.Sensors.LightSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -6650,9 +6004,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Magnetometer sender, global::Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -6677,9 +6029,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.OrientationSensor sender, global::Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -6704,9 +6054,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.Pedometer sender, global::Windows.Devices.Sensors.PedometerReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -6731,9 +6079,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.ProximitySensor sender, global::Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } /// @@ -6758,9 +6104,7 @@ namespace Windows.Devices.Sensors { void Handler(global::Windows.Devices.Sensors.SimpleOrientationSensor sender, global::Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); } } @@ -6799,9 +6143,7 @@ namespace Windows.Devices.Sensors.Custom { void Handler(global::Windows.Devices.Sensors.Custom.CustomSensor sender, global::Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); + }, x => _data.ReadingChanged += x, x => _data.ReadingChanged -= x); } } @@ -6840,9 +6182,7 @@ namespace Windows.Devices.SerialCommunication { void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.ErrorReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorReceived += x, x => _data.ErrorReceived -= x); + }, x => _data.ErrorReceived += x, x => _data.ErrorReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6850,9 +6190,7 @@ namespace Windows.Devices.SerialCommunication { void Handler(global::Windows.Devices.SerialCommunication.SerialDevice sender, global::Windows.Devices.SerialCommunication.PinChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PinChanged += x, x => _data.PinChanged -= x); + }, x => _data.PinChanged += x, x => _data.PinChanged -= x); } } @@ -6891,9 +6229,7 @@ namespace Windows.Devices.SmartCards { void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CardAdded += x, x => _data.CardAdded -= x); + }, x => _data.CardAdded += x, x => _data.CardAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -6901,9 +6237,7 @@ namespace Windows.Devices.SmartCards { void Handler(global::Windows.Devices.SmartCards.SmartCardReader sender, global::Windows.Devices.SmartCards.CardRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CardRemoved += x, x => _data.CardRemoved -= x); + }, x => _data.CardRemoved += x, x => _data.CardRemoved -= x); } } @@ -6946,9 +6280,7 @@ namespace Windows.Devices.Sms { void Handler(global::Windows.Devices.Sms.SmsDevice2 sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DeviceStatusChanged += x, x => _data.DeviceStatusChanged -= x); + }, x => _data.DeviceStatusChanged += x, x => _data.DeviceStatusChanged -= x); } /// @@ -6973,9 +6305,7 @@ namespace Windows.Devices.Sms { void Handler(global::Windows.Devices.Sms.SmsMessageRegistration sender, global::Windows.Devices.Sms.SmsMessageReceivedTriggerDetails args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } } @@ -7014,9 +6344,7 @@ namespace Windows.Devices.Usb { void Handler(global::Windows.Devices.Usb.UsbInterruptInPipe sender, global::Windows.Devices.Usb.UsbInterruptInEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); } } @@ -7055,9 +6383,7 @@ namespace Windows.Devices.WiFi { void Handler(global::Windows.Devices.WiFi.WiFiAdapter sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AvailableNetworksChanged += x, x => _data.AvailableNetworksChanged -= x); + }, x => _data.AvailableNetworksChanged += x, x => _data.AvailableNetworksChanged -= x); } } @@ -7104,9 +6430,7 @@ namespace Windows.Devices.WiFiDirect { void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher sender, global::Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } /// @@ -7131,9 +6455,7 @@ namespace Windows.Devices.WiFiDirect { void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectConnectionListener sender, global::Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); + }, x => _data.ConnectionRequested += x, x => _data.ConnectionRequested -= x); } /// @@ -7158,9 +6480,7 @@ namespace Windows.Devices.WiFiDirect { void Handler(global::Windows.Devices.WiFiDirect.WiFiDirectDevice sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); + }, x => _data.ConnectionStatusChanged += x, x => _data.ConnectionStatusChanged -= x); } } @@ -7207,9 +6527,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectService sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionDeferred += x, x => _data.SessionDeferred -= x); + }, x => _data.SessionDeferred += x, x => _data.SessionDeferred -= x); } /// @@ -7234,9 +6552,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); + }, x => _data.AdvertisementStatusChanged += x, x => _data.AdvertisementStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7244,9 +6560,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutoAcceptSessionConnected += x, x => _data.AutoAcceptSessionConnected -= x); + }, x => _data.AutoAcceptSessionConnected += x, x => _data.AutoAcceptSessionConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7254,9 +6568,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionRequested += x, x => _data.SessionRequested -= x); + }, x => _data.SessionRequested += x, x => _data.SessionRequested -= x); } /// @@ -7281,9 +6593,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemotePortAdded += x, x => _data.RemotePortAdded -= x); + }, x => _data.RemotePortAdded += x, x => _data.RemotePortAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7291,9 +6601,7 @@ namespace Windows.Devices.WiFiDirect.Services { void Handler(global::Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); + }, x => _data.SessionStatusChanged += x, x => _data.SessionStatusChanged -= x); } } @@ -7332,9 +6640,7 @@ namespace Windows.Foundation { void Handler(global::Windows.Foundation.IMemoryBufferReference sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } } @@ -7381,9 +6687,7 @@ namespace Windows.Foundation.Collections { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -7408,9 +6712,7 @@ namespace Windows.Foundation.Collections { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -7435,9 +6737,7 @@ namespace Windows.Foundation.Collections { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } } @@ -7488,9 +6788,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); } /// @@ -7515,9 +6813,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.IFileLoggingSession sender, global::Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); + }, x => _data.LogFileGenerated += x, x => _data.LogFileGenerated -= x); } /// @@ -7542,9 +6838,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); } /// @@ -7569,9 +6863,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(global::Windows.Foundation.Diagnostics.ILoggingChannel sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); + }, x => _data.LoggingEnabled += x, x => _data.LoggingEnabled -= x); } } @@ -7634,9 +6926,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7644,9 +6934,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7654,9 +6942,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -7681,9 +6967,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7691,9 +6975,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7701,9 +6983,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -7728,9 +7008,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7738,9 +7016,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7748,9 +7024,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -7775,9 +7049,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7785,9 +7057,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7795,9 +7065,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -7822,9 +7090,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7832,9 +7098,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7842,9 +7106,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -7869,9 +7131,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7879,9 +7139,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7889,9 +7147,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } /// @@ -7916,9 +7172,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); + }, x => _data.HeadsetConnected += x, x => _data.HeadsetConnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7926,9 +7180,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.Gaming.Input.Headset args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); + }, x => _data.HeadsetDisconnected += x, x => _data.HeadsetDisconnected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -7936,9 +7188,7 @@ namespace Windows.Gaming.Input { void Handler(global::Windows.Gaming.Input.IGameController sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserChanged += x, x => _data.UserChanged -= x); + }, x => _data.UserChanged += x, x => _data.UserChanged -= x); } } @@ -7981,9 +7231,7 @@ namespace Windows.Graphics.Capture { void Handler(global::Windows.Graphics.Capture.Direct3D11CaptureFramePool sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -8008,9 +7256,7 @@ namespace Windows.Graphics.Capture { void Handler(global::Windows.Graphics.Capture.GraphicsCaptureItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } } @@ -8057,9 +7303,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BrightnessLevelChanged += x, x => _data.BrightnessLevelChanged -= x); + }, x => _data.BrightnessLevelChanged += x, x => _data.BrightnessLevelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8067,9 +7311,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8077,9 +7319,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.BrightnessOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); + }, x => _data.IsSupportedChanged += x, x => _data.IsSupportedChanged -= x); } /// @@ -8104,9 +7344,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CanOverrideChanged += x, x => _data.CanOverrideChanged -= x); + }, x => _data.CanOverrideChanged += x, x => _data.CanOverrideChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8114,9 +7352,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, global::Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisplayEnhancementOverrideCapabilitiesChanged += x, x => _data.DisplayEnhancementOverrideCapabilitiesChanged -= x); + }, x => _data.DisplayEnhancementOverrideCapabilitiesChanged += x, x => _data.DisplayEnhancementOverrideCapabilitiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8124,9 +7360,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayEnhancementOverride sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); + }, x => _data.IsOverrideActiveChanged += x, x => _data.IsOverrideActiveChanged -= x); } /// @@ -8151,9 +7385,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvancedColorInfoChanged += x, x => _data.AdvancedColorInfoChanged -= x); + }, x => _data.AdvancedColorInfoChanged += x, x => _data.AdvancedColorInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8161,9 +7393,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorProfileChanged += x, x => _data.ColorProfileChanged -= x); + }, x => _data.ColorProfileChanged += x, x => _data.ColorProfileChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8171,9 +7401,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DpiChanged += x, x => _data.DpiChanged -= x); + }, x => _data.DpiChanged += x, x => _data.DpiChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8181,9 +7409,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); + }, x => _data.OrientationChanged += x, x => _data.OrientationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8191,9 +7417,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StereoEnabledChanged += x, x => _data.StereoEnabledChanged -= x); + }, x => _data.StereoEnabledChanged += x, x => _data.StereoEnabledChanged -= x); } } @@ -8232,9 +7456,7 @@ namespace Windows.Graphics.Display.Core { void Handler(global::Windows.Graphics.Display.Core.HdmiDisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisplayModesChanged += x, x => _data.DisplayModesChanged -= x); + }, x => _data.DisplayModesChanged += x, x => _data.DisplayModesChanged -= x); } } @@ -8273,9 +7495,7 @@ namespace Windows.Graphics.Holographic { void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraAdded += x, x => _data.CameraAdded -= x); + }, x => _data.CameraAdded += x, x => _data.CameraAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8283,9 +7503,7 @@ namespace Windows.Graphics.Holographic { void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, global::Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraRemoved += x, x => _data.CameraRemoved -= x); + }, x => _data.CameraRemoved += x, x => _data.CameraRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8293,9 +7511,7 @@ namespace Windows.Graphics.Holographic { void Handler(global::Windows.Graphics.Holographic.HolographicSpace sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UserPresenceChanged += x, x => _data.UserPresenceChanged -= x); + }, x => _data.UserPresenceChanged += x, x => _data.UserPresenceChanged -= x); } } @@ -8338,9 +7554,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintManager sender, global::Windows.Graphics.Printing.PrintTaskRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrintTaskRequested += x, x => _data.PrintTaskRequested -= x); + }, x => _data.PrintTaskRequested += x, x => _data.PrintTaskRequested -= x); } /// @@ -8365,9 +7579,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8375,9 +7587,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Previewing += x, x => _data.Previewing -= x); + }, x => _data.Previewing += x, x => _data.Previewing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8385,9 +7595,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, global::Windows.Graphics.Printing.PrintTaskProgressingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Progressing += x, x => _data.Progressing -= x); + }, x => _data.Progressing += x, x => _data.Progressing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8395,9 +7603,7 @@ namespace Windows.Graphics.Printing { void Handler(global::Windows.Graphics.Printing.PrintTask sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Submitting += x, x => _data.Submitting -= x); + }, x => _data.Submitting += x, x => _data.Submitting -= x); } } @@ -8436,9 +7642,7 @@ namespace Windows.Graphics.Printing.OptionDetails { void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BeginValidation += x, x => _data.BeginValidation -= x); + }, x => _data.BeginValidation += x, x => _data.BeginValidation -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8446,9 +7650,7 @@ namespace Windows.Graphics.Printing.OptionDetails { void Handler(global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails sender, global::Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionChanged += x, x => _data.OptionChanged -= x); + }, x => _data.OptionChanged += x, x => _data.OptionChanged -= x); } } @@ -8491,9 +7693,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8501,9 +7701,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Submitted += x, x => _data.Submitted -= x); + }, x => _data.Submitted += x, x => _data.Submitted -= x); } /// @@ -8528,9 +7726,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SetupRequested += x, x => _data.SetupRequested -= x); + }, x => _data.SetupRequested += x, x => _data.SetupRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8538,9 +7734,7 @@ namespace Windows.Graphics.Printing.Workflow { void Handler(global::Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession sender, global::Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.XpsDataAvailable += x, x => _data.XpsDataAvailable -= x); + }, x => _data.XpsDataAvailable += x, x => _data.XpsDataAvailable -= x); } } @@ -8579,9 +7773,7 @@ namespace Windows.Management.Policies { void Handler(global::Windows.Management.Policies.NamedPolicyData sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } } @@ -8624,9 +7816,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Ended += x, x => _data.Ended -= x); + }, x => _data.Ended += x, x => _data.Ended -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8634,9 +7824,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, global::Windows.Media.MediaTimelineControllerFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Failed += x, x => _data.Failed -= x); + }, x => _data.Failed += x, x => _data.Failed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8644,9 +7832,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8654,9 +7840,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.MediaTimelineController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -8681,9 +7865,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.AutoRepeatModeChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutoRepeatModeChangeRequested += x, x => _data.AutoRepeatModeChangeRequested -= x); + }, x => _data.AutoRepeatModeChangeRequested += x, x => _data.AutoRepeatModeChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8691,9 +7873,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8701,9 +7881,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackPositionChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackPositionChangeRequested += x, x => _data.PlaybackPositionChangeRequested -= x); + }, x => _data.PlaybackPositionChangeRequested += x, x => _data.PlaybackPositionChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8711,9 +7889,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8721,9 +7897,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8731,9 +7905,7 @@ namespace Windows.Media { void Handler(global::Windows.Media.SystemMediaTransportControls sender, global::Windows.Media.ShuffleEnabledChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShuffleEnabledChangeRequested += x, x => _data.ShuffleEnabledChangeRequested -= x); + }, x => _data.ShuffleEnabledChangeRequested += x, x => _data.ShuffleEnabledChangeRequested -= x); } } @@ -8792,9 +7964,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioFileInputNode sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileCompleted += x, x => _data.FileCompleted -= x); + }, x => _data.FileCompleted += x, x => _data.FileCompleted -= x); } /// @@ -8819,9 +7989,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.AudioFrameCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioFrameCompleted += x, x => _data.AudioFrameCompleted -= x); + }, x => _data.AudioFrameCompleted += x, x => _data.AudioFrameCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8829,9 +7997,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioFrameInputNode sender, global::Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); } /// @@ -8856,9 +8022,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuantumProcessed += x, x => _data.QuantumProcessed -= x); + }, x => _data.QuantumProcessed += x, x => _data.QuantumProcessed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8866,9 +8030,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioGraph sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); + }, x => _data.QuantumStarted += x, x => _data.QuantumStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -8876,9 +8038,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioGraph sender, global::Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnrecoverableErrorOccurred += x, x => _data.UnrecoverableErrorOccurred -= x); + }, x => _data.UnrecoverableErrorOccurred += x, x => _data.UnrecoverableErrorOccurred -= x); } /// @@ -8903,9 +8063,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.AudioStateMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SoundLevelChanged += x, x => _data.SoundLevelChanged -= x); + }, x => _data.SoundLevelChanged += x, x => _data.SoundLevelChanged -= x); } /// @@ -8930,9 +8088,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.MediaSourceAudioInputNode sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaSourceCompleted += x, x => _data.MediaSourceCompleted -= x); + }, x => _data.MediaSourceCompleted += x, x => _data.MediaSourceCompleted -= x); } /// @@ -8957,9 +8113,7 @@ namespace Windows.Media.Audio { void Handler(global::Windows.Media.Audio.SpatialAudioDeviceConfiguration sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } } @@ -9014,9 +8168,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AllPhotosCaptured += x, x => _data.AllPhotosCaptured -= x); + }, x => _data.AllPhotosCaptured += x, x => _data.AllPhotosCaptured -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9024,9 +8176,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.AdvancedPhotoCapture sender, global::Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionalReferencePhotoCaptured += x, x => _data.OptionalReferencePhotoCaptured -= x); + }, x => _data.OptionalReferencePhotoCaptured += x, x => _data.OptionalReferencePhotoCaptured -= x); } /// @@ -9051,9 +8201,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.AppCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CapturingChanged += x, x => _data.CapturingChanged -= x); + }, x => _data.CapturingChanged += x, x => _data.CapturingChanged -= x); } /// @@ -9078,9 +8226,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.LowLagPhotoSequenceCapture sender, global::Windows.Media.Capture.PhotoCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); } /// @@ -9105,9 +8251,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CameraStreamStateChanged += x, x => _data.CameraStreamStateChanged -= x); + }, x => _data.CameraStreamStateChanged += x, x => _data.CameraStreamStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9115,9 +8259,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CaptureDeviceExclusiveControlStatusChanged += x, x => _data.CaptureDeviceExclusiveControlStatusChanged -= x); + }, x => _data.CaptureDeviceExclusiveControlStatusChanged += x, x => _data.CaptureDeviceExclusiveControlStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9125,9 +8267,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFailedEventArgs errorEventArgs) => eventHandler((sender, errorEventArgs)); return Handler; - } - - , x => _data.Failed += x, x => _data.Failed -= x); + }, x => _data.Failed += x, x => _data.Failed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9135,9 +8275,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.MediaCaptureFocusChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusChanged += x, x => _data.FocusChanged -= x); + }, x => _data.FocusChanged += x, x => _data.FocusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9145,9 +8283,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, global::Windows.Media.Capture.PhotoConfirmationCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PhotoConfirmationCaptured += x, x => _data.PhotoConfirmationCaptured -= x); + }, x => _data.PhotoConfirmationCaptured += x, x => _data.PhotoConfirmationCaptured -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9155,9 +8291,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender) => eventHandler(sender); return Handler; - } - - , x => _data.RecordLimitationExceeded += x, x => _data.RecordLimitationExceeded -= x); + }, x => _data.RecordLimitationExceeded += x, x => _data.RecordLimitationExceeded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9165,9 +8299,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.MediaCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThermalStatusChanged += x, x => _data.ThermalStatusChanged -= x); + }, x => _data.ThermalStatusChanged += x, x => _data.ThermalStatusChanged -= x); } /// @@ -9192,9 +8324,7 @@ namespace Windows.Media.Capture { void Handler(global::Windows.Media.Capture.ScreenCapture sender, global::Windows.Media.Capture.SourceSuspensionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceSuspensionChanged += x, x => _data.SourceSuspensionChanged -= x); + }, x => _data.SourceSuspensionChanged += x, x => _data.SourceSuspensionChanged -= x); } } @@ -9233,9 +8363,7 @@ namespace Windows.Media.Capture.Core { void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, global::Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); + }, x => _data.PhotoCaptured += x, x => _data.PhotoCaptured -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9243,9 +8371,7 @@ namespace Windows.Media.Capture.Core { void Handler(global::Windows.Media.Capture.Core.VariablePhotoSequenceCapture sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -9292,9 +8418,7 @@ namespace Windows.Media.Capture.Frames { void Handler(global::Windows.Media.Capture.Frames.MediaFrameReader sender, global::Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } /// @@ -9319,9 +8443,7 @@ namespace Windows.Media.Capture.Frames { void Handler(global::Windows.Media.Capture.Frames.MediaFrameSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FormatChanged += x, x => _data.FormatChanged -= x); + }, x => _data.FormatChanged += x, x => _data.FormatChanged -= x); } /// @@ -9346,9 +8468,7 @@ namespace Windows.Media.Capture.Frames { void Handler(global::Windows.Media.Capture.Frames.MultiSourceMediaFrameReader sender, global::Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameArrived += x, x => _data.FrameArrived -= x); + }, x => _data.FrameArrived += x, x => _data.FrameArrived -= x); } } @@ -9391,9 +8511,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingConnection sender, global::Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9401,9 +8519,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingConnection sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -9428,9 +8544,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CastingDevicePickerDismissed += x, x => _data.CastingDevicePickerDismissed -= x); + }, x => _data.CastingDevicePickerDismissed += x, x => _data.CastingDevicePickerDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9438,9 +8552,7 @@ namespace Windows.Media.Casting { void Handler(global::Windows.Media.Casting.CastingDevicePicker sender, global::Windows.Media.Casting.CastingDeviceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CastingDeviceSelected += x, x => _data.CastingDeviceSelected -= x); + }, x => _data.CastingDeviceSelected += x, x => _data.CastingDeviceSelected -= x); } } @@ -9479,9 +8591,7 @@ namespace Windows.Media.ContentRestrictions { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.RestrictionsChanged += x, x => _data.RestrictionsChanged -= x); + }, x => _data.RestrictionsChanged += x, x => _data.RestrictionsChanged -= x); } } @@ -9524,9 +8634,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.MediaPropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaPropertiesChanged += x, x => _data.MediaPropertiesChanged -= x); + }, x => _data.MediaPropertiesChanged += x, x => _data.MediaPropertiesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9534,9 +8642,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.PlaybackInfoChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackInfoChanged += x, x => _data.PlaybackInfoChanged -= x); + }, x => _data.PlaybackInfoChanged += x, x => _data.PlaybackInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9544,9 +8650,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSession sender, global::Windows.Media.Control.TimelinePropertiesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimelinePropertiesChanged += x, x => _data.TimelinePropertiesChanged -= x); + }, x => _data.TimelinePropertiesChanged += x, x => _data.TimelinePropertiesChanged -= x); } /// @@ -9571,9 +8675,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.CurrentSessionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentSessionChanged += x, x => _data.CurrentSessionChanged -= x); + }, x => _data.CurrentSessionChanged += x, x => _data.CurrentSessionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9581,9 +8683,7 @@ namespace Windows.Media.Control { void Handler(global::Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager sender, global::Windows.Media.Control.SessionsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SessionsChanged += x, x => _data.SessionsChanged -= x); + }, x => _data.SessionsChanged += x, x => _data.SessionsChanged -= x); } } @@ -9686,9 +8786,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.AudioTrack sender, global::Windows.Media.Core.AudioTrackOpenFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); } /// @@ -9713,9 +8811,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.FaceDetectionEffect sender, global::Windows.Media.Core.FaceDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FaceDetected += x, x => _data.FaceDetected -= x); + }, x => _data.FaceDetected += x, x => _data.FaceDetected -= x); } /// @@ -9740,9 +8836,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -9767,9 +8861,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaBinder sender, global::Windows.Media.Core.MediaBindingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Binding += x, x => _data.Binding -= x); + }, x => _data.Binding += x, x => _data.Binding -= x); } /// @@ -9794,9 +8886,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaBindingEventArgs sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); } /// @@ -9821,9 +8911,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenOperationCompleted += x, x => _data.OpenOperationCompleted -= x); + }, x => _data.OpenOperationCompleted += x, x => _data.OpenOperationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9831,9 +8919,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaSource sender, global::Windows.Media.Core.MediaSourceStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -9858,9 +8944,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaSourceAppServiceConnection sender, global::Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InitializeMediaStreamSourceRequested += x, x => _data.InitializeMediaStreamSourceRequested -= x); + }, x => _data.InitializeMediaStreamSourceRequested += x, x => _data.InitializeMediaStreamSourceRequested -= x); } /// @@ -9885,9 +8969,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSample sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Processed += x, x => _data.Processed -= x); + }, x => _data.Processed += x, x => _data.Processed -= x); } /// @@ -9912,9 +8994,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9922,9 +9002,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Paused += x, x => _data.Paused -= x); + }, x => _data.Paused += x, x => _data.Paused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9932,9 +9010,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SampleRendered += x, x => _data.SampleRendered -= x); + }, x => _data.SampleRendered += x, x => _data.SampleRendered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9942,9 +9018,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SampleRequested += x, x => _data.SampleRequested -= x); + }, x => _data.SampleRequested += x, x => _data.SampleRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9952,9 +9026,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Starting += x, x => _data.Starting -= x); + }, x => _data.Starting += x, x => _data.Starting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9962,9 +9034,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MediaStreamSource sender, global::Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SwitchStreamsRequested += x, x => _data.SwitchStreamsRequested -= x); + }, x => _data.SwitchStreamsRequested += x, x => _data.SwitchStreamsRequested -= x); } /// @@ -9989,9 +9059,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Aborted += x, x => _data.Aborted -= x); + }, x => _data.Aborted += x, x => _data.Aborted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -9999,9 +9067,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10009,9 +9075,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10019,9 +9083,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateEnded += x, x => _data.UpdateEnded -= x); + }, x => _data.UpdateEnded += x, x => _data.UpdateEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10029,9 +9091,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBuffer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UpdateStarting += x, x => _data.UpdateStarting -= x); + }, x => _data.UpdateStarting += x, x => _data.UpdateStarting -= x); } /// @@ -10056,9 +9116,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceBufferAdded += x, x => _data.SourceBufferAdded -= x); + }, x => _data.SourceBufferAdded += x, x => _data.SourceBufferAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10066,9 +9124,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseSourceBufferList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceBufferRemoved += x, x => _data.SourceBufferRemoved -= x); + }, x => _data.SourceBufferRemoved += x, x => _data.SourceBufferRemoved -= x); } /// @@ -10093,9 +9149,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10103,9 +9157,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Ended += x, x => _data.Ended -= x); + }, x => _data.Ended += x, x => _data.Ended -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10113,9 +9165,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.MseStreamSource sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -10140,9 +9190,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.SceneAnalysisEffect sender, global::Windows.Media.Core.SceneAnalyzedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SceneAnalyzed += x, x => _data.SceneAnalyzed -= x); + }, x => _data.SceneAnalyzed += x, x => _data.SceneAnalyzed -= x); } /// @@ -10167,9 +9215,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CueEntered += x, x => _data.CueEntered -= x); + }, x => _data.CueEntered += x, x => _data.CueEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10177,9 +9223,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.MediaCueEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CueExited += x, x => _data.CueExited -= x); + }, x => _data.CueExited += x, x => _data.CueExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10187,9 +9231,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedMetadataTrack sender, global::Windows.Media.Core.TimedMetadataTrackFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TrackFailed += x, x => _data.TrackFailed -= x); + }, x => _data.TrackFailed += x, x => _data.TrackFailed -= x); } /// @@ -10214,9 +9256,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.TimedTextSource sender, global::Windows.Media.Core.TimedTextSourceResolveResultEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Resolved += x, x => _data.Resolved -= x); + }, x => _data.Resolved += x, x => _data.Resolved -= x); } /// @@ -10241,9 +9281,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.VideoStabilizationEffect sender, global::Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); + }, x => _data.EnabledChanged += x, x => _data.EnabledChanged -= x); } /// @@ -10268,9 +9306,7 @@ namespace Windows.Media.Core { void Handler(global::Windows.Media.Core.VideoTrack sender, global::Windows.Media.Core.VideoTrackOpenFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); } } @@ -10309,9 +9345,7 @@ namespace Windows.Media.Devices { void Handler(global::Windows.Media.Devices.AudioDeviceModulesManager sender, global::Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ModuleNotificationReceived += x, x => _data.ModuleNotificationReceived -= x); + }, x => _data.ModuleNotificationReceived += x, x => _data.ModuleNotificationReceived -= x); } } @@ -10350,9 +9384,7 @@ namespace Windows.Media.DialProtocol { void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DialDevicePickerDismissed += x, x => _data.DialDevicePickerDismissed -= x); + }, x => _data.DialDevicePickerDismissed += x, x => _data.DialDevicePickerDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10360,9 +9392,7 @@ namespace Windows.Media.DialProtocol { void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDeviceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DialDeviceSelected += x, x => _data.DialDeviceSelected -= x); + }, x => _data.DialDeviceSelected += x, x => _data.DialDeviceSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10370,9 +9400,7 @@ namespace Windows.Media.DialProtocol { void Handler(global::Windows.Media.DialProtocol.DialDevicePicker sender, global::Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); + }, x => _data.DisconnectButtonClicked += x, x => _data.DisconnectButtonClicked -= x); } } @@ -10415,9 +9443,7 @@ namespace Windows.Media.Effects { void Handler(global::Windows.Media.Effects.AudioCaptureEffectsManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioCaptureEffectsChanged += x, x => _data.AudioCaptureEffectsChanged -= x); + }, x => _data.AudioCaptureEffectsChanged += x, x => _data.AudioCaptureEffectsChanged -= x); } /// @@ -10442,9 +9468,7 @@ namespace Windows.Media.Effects { void Handler(global::Windows.Media.Effects.AudioRenderEffectsManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioRenderEffectsChanged += x, x => _data.AudioRenderEffectsChanged -= x); + }, x => _data.AudioRenderEffectsChanged += x, x => _data.AudioRenderEffectsChanged -= x); } } @@ -10483,9 +9507,7 @@ namespace Windows.Media.Import { void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportItemImportedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemImported += x, x => _data.ItemImported -= x); + }, x => _data.ItemImported += x, x => _data.ItemImported -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10493,9 +9515,7 @@ namespace Windows.Media.Import { void Handler(global::Windows.Media.Import.PhotoImportFindItemsResult sender, global::Windows.Media.Import.PhotoImportSelectionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } } @@ -10574,9 +9594,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreakEnded += x, x => _data.BreakEnded -= x); + }, x => _data.BreakEnded += x, x => _data.BreakEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10584,9 +9602,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSkippedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreakSkipped += x, x => _data.BreakSkipped -= x); + }, x => _data.BreakSkipped += x, x => _data.BreakSkipped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10594,9 +9610,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakSeekedOverEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreaksSeekedOver += x, x => _data.BreaksSeekedOver -= x); + }, x => _data.BreaksSeekedOver += x, x => _data.BreaksSeekedOver -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10604,9 +9618,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakManager sender, global::Windows.Media.Playback.MediaBreakStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BreakStarted += x, x => _data.BreakStarted -= x); + }, x => _data.BreakStarted += x, x => _data.BreakStarted -= x); } /// @@ -10631,9 +9643,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaBreakSchedule sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScheduleChanged += x, x => _data.ScheduleChanged -= x); + }, x => _data.ScheduleChanged += x, x => _data.ScheduleChanged -= x); } /// @@ -10658,9 +9668,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -10685,9 +9693,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutoRepeatModeReceived += x, x => _data.AutoRepeatModeReceived -= x); + }, x => _data.AutoRepeatModeReceived += x, x => _data.AutoRepeatModeReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10695,9 +9701,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FastForwardReceived += x, x => _data.FastForwardReceived -= x); + }, x => _data.FastForwardReceived += x, x => _data.FastForwardReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10705,9 +9709,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NextReceived += x, x => _data.NextReceived -= x); + }, x => _data.NextReceived += x, x => _data.NextReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10715,9 +9717,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PauseReceived += x, x => _data.PauseReceived -= x); + }, x => _data.PauseReceived += x, x => _data.PauseReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10725,9 +9725,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlayReceived += x, x => _data.PlayReceived -= x); + }, x => _data.PlayReceived += x, x => _data.PlayReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10735,9 +9733,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionReceived += x, x => _data.PositionReceived -= x); + }, x => _data.PositionReceived += x, x => _data.PositionReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10745,9 +9741,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PreviousReceived += x, x => _data.PreviousReceived -= x); + }, x => _data.PreviousReceived += x, x => _data.PreviousReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10755,9 +9749,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RateReceived += x, x => _data.RateReceived -= x); + }, x => _data.RateReceived += x, x => _data.RateReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10765,9 +9757,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RewindReceived += x, x => _data.RewindReceived -= x); + }, x => _data.RewindReceived += x, x => _data.RewindReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10775,9 +9765,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManager sender, global::Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShuffleReceived += x, x => _data.ShuffleReceived -= x); + }, x => _data.ShuffleReceived += x, x => _data.ShuffleReceived -= x); } /// @@ -10802,9 +9790,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); } /// @@ -10829,9 +9815,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioTracksChanged += x, x => _data.AudioTracksChanged -= x); + }, x => _data.AudioTracksChanged += x, x => _data.AudioTracksChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10839,9 +9823,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimedMetadataTracksChanged += x, x => _data.TimedMetadataTracksChanged -= x); + }, x => _data.TimedMetadataTracksChanged += x, x => _data.TimedMetadataTracksChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10849,9 +9831,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackItem sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoTracksChanged += x, x => _data.VideoTracksChanged -= x); + }, x => _data.VideoTracksChanged += x, x => _data.VideoTracksChanged -= x); } /// @@ -10876,9 +9856,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10886,9 +9864,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemFailed += x, x => _data.ItemFailed -= x); + }, x => _data.ItemFailed += x, x => _data.ItemFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10896,9 +9872,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackList sender, global::Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemOpened += x, x => _data.ItemOpened -= x); + }, x => _data.ItemOpened += x, x => _data.ItemOpened -= x); } /// @@ -10923,9 +9897,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferedRangesChanged += x, x => _data.BufferedRangesChanged -= x); + }, x => _data.BufferedRangesChanged += x, x => _data.BufferedRangesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10933,9 +9905,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10943,9 +9913,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10953,9 +9921,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10963,9 +9929,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10973,9 +9937,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NaturalDurationChanged += x, x => _data.NaturalDurationChanged -= x); + }, x => _data.NaturalDurationChanged += x, x => _data.NaturalDurationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10983,9 +9945,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NaturalVideoSizeChanged += x, x => _data.NaturalVideoSizeChanged -= x); + }, x => _data.NaturalVideoSizeChanged += x, x => _data.NaturalVideoSizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -10993,9 +9953,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackRateChanged += x, x => _data.PlaybackRateChanged -= x); + }, x => _data.PlaybackRateChanged += x, x => _data.PlaybackRateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11003,9 +9961,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackStateChanged += x, x => _data.PlaybackStateChanged -= x); + }, x => _data.PlaybackStateChanged += x, x => _data.PlaybackStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11013,9 +9969,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlayedRangesChanged += x, x => _data.PlayedRangesChanged -= x); + }, x => _data.PlayedRangesChanged += x, x => _data.PlayedRangesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11023,9 +9977,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11033,9 +9985,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeekableRangesChanged += x, x => _data.SeekableRangesChanged -= x); + }, x => _data.SeekableRangesChanged += x, x => _data.SeekableRangesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11043,9 +9993,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11053,9 +10001,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SupportedPlaybackRatesChanged += x, x => _data.SupportedPlaybackRatesChanged -= x); + }, x => _data.SupportedPlaybackRatesChanged += x, x => _data.SupportedPlaybackRatesChanged -= x); } /// @@ -11080,9 +10026,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList sender, global::Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PresentationModeChanged += x, x => _data.PresentationModeChanged -= x); + }, x => _data.PresentationModeChanged += x, x => _data.PresentationModeChanged -= x); } /// @@ -11107,9 +10051,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Core.ISingleSelectMediaTrackList sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -11134,9 +10076,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); + }, x => _data.BufferingEnded += x, x => _data.BufferingEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11144,9 +10084,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11154,9 +10092,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11164,9 +10100,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsMutedChanged += x, x => _data.IsMutedChanged -= x); + }, x => _data.IsMutedChanged += x, x => _data.IsMutedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11174,9 +10108,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11184,9 +10116,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11194,9 +10124,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11204,9 +10132,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.MediaPlayerRateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MediaPlayerRateChanged += x, x => _data.MediaPlayerRateChanged -= x); + }, x => _data.MediaPlayerRateChanged += x, x => _data.MediaPlayerRateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11214,9 +10140,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, global::Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackMediaMarkerReached += x, x => _data.PlaybackMediaMarkerReached -= x); + }, x => _data.PlaybackMediaMarkerReached += x, x => _data.PlaybackMediaMarkerReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11224,9 +10148,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11234,9 +10156,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceChanged += x, x => _data.SourceChanged -= x); + }, x => _data.SourceChanged += x, x => _data.SourceChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11244,9 +10164,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SubtitleFrameChanged += x, x => _data.SubtitleFrameChanged -= x); + }, x => _data.SubtitleFrameChanged += x, x => _data.SubtitleFrameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11254,9 +10172,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoFrameAvailable += x, x => _data.VideoFrameAvailable -= x); + }, x => _data.VideoFrameAvailable += x, x => _data.VideoFrameAvailable -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11264,9 +10180,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, double args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VideoRatioChanged += x, x => _data.VideoRatioChanged -= x); + }, x => _data.VideoRatioChanged += x, x => _data.VideoRatioChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11274,9 +10188,7 @@ namespace Windows.Media.Playback { void Handler(global::Windows.Media.Playback.MediaPlayer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); } } @@ -11323,9 +10235,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionErrorEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Error += x, x => _data.Error -= x); + }, x => _data.Error += x, x => _data.Error -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11333,9 +10243,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11343,9 +10251,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToConnection sender, global::Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Transferred += x, x => _data.Transferred -= x); + }, x => _data.Transferred += x, x => _data.Transferred -= x); } /// @@ -11370,9 +10276,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceRequested += x, x => _data.SourceRequested -= x); + }, x => _data.SourceRequested += x, x => _data.SourceRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11380,9 +10284,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToManager sender, global::Windows.Media.PlayTo.PlayToSourceSelectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceSelected += x, x => _data.SourceSelected -= x); + }, x => _data.SourceSelected += x, x => _data.SourceSelected -= x); } /// @@ -11407,9 +10309,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CurrentTimeChangeRequested += x, x => _data.CurrentTimeChangeRequested -= x); + }, x => _data.CurrentTimeChangeRequested += x, x => _data.CurrentTimeChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11417,9 +10317,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.MuteChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MuteChangeRequested += x, x => _data.MuteChangeRequested -= x); + }, x => _data.MuteChangeRequested += x, x => _data.MuteChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11427,9 +10325,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PauseRequested += x, x => _data.PauseRequested -= x); + }, x => _data.PauseRequested += x, x => _data.PauseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11437,9 +10333,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); + }, x => _data.PlaybackRateChangeRequested += x, x => _data.PlaybackRateChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11447,9 +10341,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlayRequested += x, x => _data.PlayRequested -= x); + }, x => _data.PlayRequested += x, x => _data.PlayRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11457,9 +10349,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.SourceChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceChangeRequested += x, x => _data.SourceChangeRequested -= x); + }, x => _data.SourceChangeRequested += x, x => _data.SourceChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11467,9 +10357,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StopRequested += x, x => _data.StopRequested -= x); + }, x => _data.StopRequested += x, x => _data.StopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11477,9 +10365,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimeUpdateRequested += x, x => _data.TimeUpdateRequested -= x); + }, x => _data.TimeUpdateRequested += x, x => _data.TimeUpdateRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11487,9 +10373,7 @@ namespace Windows.Media.PlayTo { void Handler(global::Windows.Media.PlayTo.PlayToReceiver sender, global::Windows.Media.PlayTo.VolumeChangeRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VolumeChangeRequested += x, x => _data.VolumeChangeRequested -= x); + }, x => _data.VolumeChangeRequested += x, x => _data.VolumeChangeRequested -= x); } } @@ -11532,9 +10416,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.HdcpSession sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProtectionChanged += x, x => _data.ProtectionChanged -= x); + }, x => _data.ProtectionChanged += x, x => _data.ProtectionChanged -= x); } /// @@ -11559,9 +10441,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ComponentLoadFailedEventArgs e) => eventHandler((sender, e)); return Handler; - } - - , x => _data.ComponentLoadFailed += x, x => _data.ComponentLoadFailed -= x); + }, x => _data.ComponentLoadFailed += x, x => _data.ComponentLoadFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11569,9 +10449,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.MediaProtectionManager sender) => eventHandler(sender); return Handler; - } - - , x => _data.RebootNeeded += x, x => _data.RebootNeeded -= x); + }, x => _data.RebootNeeded += x, x => _data.RebootNeeded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11579,9 +10457,7 @@ namespace Windows.Media.Protection { void Handler(global::Windows.Media.Protection.MediaProtectionManager sender, global::Windows.Media.Protection.ServiceRequestedEventArgs e) => eventHandler((sender, e)); return Handler; - } - - , x => _data.ServiceRequested += x, x => _data.ServiceRequested -= x); + }, x => _data.ServiceRequested += x, x => _data.ServiceRequested -= x); } } @@ -11620,9 +10496,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ClosedCaptionDataReceived += x, x => _data.ClosedCaptionDataReceived -= x); + }, x => _data.ClosedCaptionDataReceived += x, x => _data.ClosedCaptionDataReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11630,9 +10504,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LicenseFetchCompleted += x, x => _data.LicenseFetchCompleted -= x); + }, x => _data.LicenseFetchCompleted += x, x => _data.LicenseFetchCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11640,9 +10512,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProximityDetectionCompleted += x, x => _data.ProximityDetectionCompleted -= x); + }, x => _data.ProximityDetectionCompleted += x, x => _data.ProximityDetectionCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11650,9 +10520,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, global::Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RegistrationCompleted += x, x => _data.RegistrationCompleted -= x); + }, x => _data.RegistrationCompleted += x, x => _data.RegistrationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11660,9 +10528,7 @@ namespace Windows.Media.Protection.PlayReady { void Handler(global::Windows.Media.Protection.PlayReady.NDClient sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ReRegistrationNeeded += x, x => _data.ReRegistrationNeeded -= x); + }, x => _data.ReRegistrationNeeded += x, x => _data.ReRegistrationNeeded -= x); } } @@ -11705,9 +10571,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11715,9 +10579,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession sender, global::Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResultGenerated += x, x => _data.ResultGenerated -= x); + }, x => _data.ResultGenerated += x, x => _data.ResultGenerated -= x); } /// @@ -11742,9 +10604,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HypothesisGenerated += x, x => _data.HypothesisGenerated -= x); + }, x => _data.HypothesisGenerated += x, x => _data.HypothesisGenerated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11752,9 +10612,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RecognitionQualityDegrading += x, x => _data.RecognitionQualityDegrading -= x); + }, x => _data.RecognitionQualityDegrading += x, x => _data.RecognitionQualityDegrading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11762,9 +10620,7 @@ namespace Windows.Media.SpeechRecognition { void Handler(global::Windows.Media.SpeechRecognition.SpeechRecognizer sender, global::Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } } @@ -11807,9 +10663,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadBitrateChanged += x, x => _data.DownloadBitrateChanged -= x); + }, x => _data.DownloadBitrateChanged += x, x => _data.DownloadBitrateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11817,9 +10671,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); + }, x => _data.DownloadCompleted += x, x => _data.DownloadCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11827,9 +10679,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); + }, x => _data.DownloadFailed += x, x => _data.DownloadFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11837,9 +10687,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DownloadRequested += x, x => _data.DownloadRequested -= x); + }, x => _data.DownloadRequested += x, x => _data.DownloadRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -11847,9 +10695,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSource sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PlaybackBitrateChanged += x, x => _data.PlaybackBitrateChanged -= x); + }, x => _data.PlaybackBitrateChanged += x, x => _data.PlaybackBitrateChanged -= x); } /// @@ -11874,9 +10720,7 @@ namespace Windows.Media.Streaming.Adaptive { void Handler(global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics sender, global::Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DiagnosticAvailable += x, x => _data.DiagnosticAvailable -= x); + }, x => _data.DiagnosticAvailable += x, x => _data.DiagnosticAvailable -= x); } } @@ -11915,9 +10759,7 @@ namespace Windows.Networking.BackgroundTransfer { void Handler(global::Windows.Networking.BackgroundTransfer.DownloadOperation sender, global::Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RangesDownloaded += x, x => _data.RangesDownloaded -= x); + }, x => _data.RangesDownloaded += x, x => _data.RangesDownloaded -= x); } } @@ -11980,9 +10822,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESim sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProfileChanged += x, x => _data.ProfileChanged -= x); + }, x => _data.ProfileChanged += x, x => _data.ProfileChanged -= x); } /// @@ -12007,9 +10847,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimProfileMetadata sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StateChanged += x, x => _data.StateChanged -= x); + }, x => _data.StateChanged += x, x => _data.StateChanged -= x); } /// @@ -12034,9 +10872,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12044,9 +10880,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12054,9 +10888,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12064,9 +10896,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12074,9 +10904,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.ESimWatcher sender, global::Windows.Networking.NetworkOperators.ESimUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -12101,9 +10929,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountAdded += x, x => _data.AccountAdded -= x); + }, x => _data.AccountAdded += x, x => _data.AccountAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12111,9 +10937,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountRemoved += x, x => _data.AccountRemoved -= x); + }, x => _data.AccountRemoved += x, x => _data.AccountRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12121,9 +10945,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, global::Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountUpdated += x, x => _data.AccountUpdated -= x); + }, x => _data.AccountUpdated += x, x => _data.AccountUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12131,9 +10953,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12141,9 +10961,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -12168,9 +10986,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession sender, global::Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataReceived += x, x => _data.DataReceived -= x); + }, x => _data.DataReceived += x, x => _data.DataReceived -= x); } /// @@ -12195,9 +11011,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandModem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsInEmergencyCallModeChanged += x, x => _data.IsInEmergencyCallModeChanged -= x); + }, x => _data.IsInEmergencyCallModeChanged += x, x => _data.IsInEmergencyCallModeChanged -= x); } /// @@ -12222,9 +11036,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(global::Windows.Networking.NetworkOperators.MobileBroadbandSarManager sender, global::Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TransmissionStateChanged += x, x => _data.TransmissionStateChanged -= x); + }, x => _data.TransmissionStateChanged += x, x => _data.TransmissionStateChanged -= x); } } @@ -12267,9 +11079,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12277,9 +11087,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12287,9 +11095,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12297,9 +11103,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12307,9 +11111,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.PeerWatcher sender, global::Windows.Networking.Proximity.PeerInformation args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -12334,9 +11136,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); return Handler; - } - - , x => _data.DeviceArrived += x, x => _data.DeviceArrived -= x); + }, x => _data.DeviceArrived += x, x => _data.DeviceArrived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12344,9 +11144,7 @@ namespace Windows.Networking.Proximity { void Handler(global::Windows.Networking.Proximity.ProximityDevice sender) => eventHandler(sender); return Handler; - } - - , x => _data.DeviceDeparted += x, x => _data.DeviceDeparted -= x); + }, x => _data.DeviceDeparted += x, x => _data.DeviceDeparted -= x); } } @@ -12385,9 +11183,7 @@ namespace Windows.Networking.PushNotifications { void Handler(global::Windows.Networking.PushNotifications.PushNotificationChannel sender, global::Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PushNotificationReceived += x, x => _data.PushNotificationReceived -= x); + }, x => _data.PushNotificationReceived += x, x => _data.PushNotificationReceived -= x); } } @@ -12426,9 +11222,7 @@ namespace Windows.Networking.ServiceDiscovery.Dnssd { void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12436,9 +11230,7 @@ namespace Windows.Networking.ServiceDiscovery.Dnssd { void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12446,9 +11238,7 @@ namespace Windows.Networking.ServiceDiscovery.Dnssd { void Handler(global::Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } } @@ -12511,9 +11301,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.DatagramSocket sender, global::Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } /// @@ -12538,9 +11326,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } /// @@ -12565,9 +11351,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12575,9 +11359,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12585,9 +11367,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.MessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); } /// @@ -12612,9 +11392,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12622,9 +11400,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.ServerMessageWebSocket sender, global::Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MessageReceived += x, x => _data.MessageReceived -= x); + }, x => _data.MessageReceived += x, x => _data.MessageReceived -= x); } /// @@ -12649,9 +11425,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.ServerStreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); } /// @@ -12676,9 +11450,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.StreamSocketListener sender, global::Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ConnectionReceived += x, x => _data.ConnectionReceived -= x); + }, x => _data.ConnectionReceived += x, x => _data.ConnectionReceived -= x); } /// @@ -12703,9 +11475,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.IWebSocket sender, global::Windows.Networking.Sockets.WebSocketClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12713,9 +11483,7 @@ namespace Windows.Networking.Sockets { void Handler(global::Windows.Networking.Sockets.StreamWebSocket sender, global::Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); } } @@ -12754,9 +11522,7 @@ namespace Windows.Networking.Vpn { void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActivityChange += x, x => _data.ActivityChange -= x); + }, x => _data.ActivityChange += x, x => _data.ActivityChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12764,9 +11530,7 @@ namespace Windows.Networking.Vpn { void Handler(global::Windows.Networking.Vpn.VpnChannel sender, global::Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActivityStateChange += x, x => _data.ActivityStateChange -= x); + }, x => _data.ActivityStateChange += x, x => _data.ActivityStateChange -= x); } } @@ -12813,9 +11577,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialAnchor sender, global::Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RawCoordinateSystemAdjusted += x, x => _data.RawCoordinateSystemAdjusted -= x); + }, x => _data.RawCoordinateSystemAdjusted += x, x => _data.RawCoordinateSystemAdjusted -= x); } /// @@ -12840,9 +11602,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12850,9 +11610,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12860,9 +11618,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12870,9 +11626,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialEntityWatcher sender, global::Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -12897,9 +11651,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LocatabilityChanged += x, x => _data.LocatabilityChanged -= x); + }, x => _data.LocatabilityChanged += x, x => _data.LocatabilityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -12907,9 +11659,7 @@ namespace Windows.Perception.Spatial { void Handler(global::Windows.Perception.Spatial.SpatialLocator sender, global::Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PositionalTrackingDeactivating += x, x => _data.PositionalTrackingDeactivating -= x); + }, x => _data.PositionalTrackingDeactivating += x, x => _data.PositionalTrackingDeactivating -= x); } } @@ -12948,9 +11698,7 @@ namespace Windows.Perception.Spatial.Surfaces { void Handler(global::Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ObservedSurfacesChanged += x, x => _data.ObservedSurfacesChanged -= x); + }, x => _data.ObservedSurfacesChanged += x, x => _data.ObservedSurfacesChanged -= x); } } @@ -12989,9 +11737,7 @@ namespace Windows.Phone.Devices.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingChargePercentChanged += x, x => _data.RemainingChargePercentChanged -= x); + }, x => _data.RemainingChargePercentChanged += x, x => _data.RemainingChargePercentChanged -= x); } } @@ -13030,9 +11776,7 @@ namespace Windows.Phone.Media.Devices { void Handler(global::Windows.Phone.Media.Devices.AudioRoutingManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AudioEndpointChanged += x, x => _data.AudioEndpointChanged -= x); + }, x => _data.AudioEndpointChanged += x, x => _data.AudioEndpointChanged -= x); } } @@ -13071,9 +11815,7 @@ namespace Windows.Security.Authentication.Web.Core { void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DefaultSignInAccountChanged += x, x => _data.DefaultSignInAccountChanged -= x); + }, x => _data.DefaultSignInAccountChanged += x, x => _data.DefaultSignInAccountChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13081,9 +11823,7 @@ namespace Windows.Security.Authentication.Web.Core { void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13091,9 +11831,7 @@ namespace Windows.Security.Authentication.Web.Core { void Handler(global::Windows.Security.Authentication.Web.Core.WebAccountMonitor sender, global::Windows.Security.Authentication.Web.Core.WebAccountEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -13132,9 +11870,7 @@ namespace Windows.Security.Credentials { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } } @@ -13173,9 +11909,7 @@ namespace Windows.Services.Maps.OfflineMaps { void Handler(global::Windows.Services.Maps.OfflineMaps.OfflineMapPackage sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StatusChanged += x, x => _data.StatusChanged -= x); + }, x => _data.StatusChanged += x, x => _data.StatusChanged -= x); } } @@ -13226,9 +11960,7 @@ namespace Windows.Storage { void Handler(global::Windows.Storage.ApplicationData sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataChanged += x, x => _data.DataChanged -= x); + }, x => _data.DataChanged += x, x => _data.DataChanged -= x); } /// @@ -13253,9 +11985,7 @@ namespace Windows.Storage { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -13280,9 +12010,7 @@ namespace Windows.Storage { void Handler(global::Windows.Foundation.Collections.IObservableMap sender, global::Windows.Foundation.Collections.IMapChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.MapChanged += x, x => _data.MapChanged -= x); + }, x => _data.MapChanged += x, x => _data.MapChanged -= x); } /// @@ -13307,9 +12035,7 @@ namespace Windows.Storage { void Handler(global::Windows.Storage.StorageLibrary sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DefinitionChanged += x, x => _data.DefinitionChanged -= x); + }, x => _data.DefinitionChanged += x, x => _data.DefinitionChanged -= x); } } @@ -13348,9 +12074,7 @@ namespace Windows.Storage.AccessCache { void Handler(global::Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList sender, global::Windows.Storage.AccessCache.ItemRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); + }, x => _data.ItemRemoved += x, x => _data.ItemRemoved -= x); } } @@ -13397,9 +12121,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13407,9 +12129,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); } /// @@ -13434,9 +12154,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13444,9 +12162,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); } /// @@ -13471,9 +12187,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); + }, x => _data.PropertiesUpdated += x, x => _data.PropertiesUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13481,9 +12195,7 @@ namespace Windows.Storage.BulkAccess { void Handler(global::Windows.Storage.BulkAccess.IStorageItemInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); + }, x => _data.ThumbnailUpdated += x, x => _data.ThumbnailUpdated -= x); } } @@ -13526,9 +12238,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.PickerClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13536,9 +12246,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileOpenPickerUI sender, global::Windows.Storage.Pickers.Provider.FileRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileRemoved += x, x => _data.FileRemoved -= x); + }, x => _data.FileRemoved += x, x => _data.FileRemoved -= x); } /// @@ -13563,9 +12271,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileNameChanged += x, x => _data.FileNameChanged -= x); + }, x => _data.FileNameChanged += x, x => _data.FileNameChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13573,9 +12279,7 @@ namespace Windows.Storage.Pickers.Provider { void Handler(global::Windows.Storage.Pickers.Provider.FileSavePickerUI sender, global::Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetFileRequested += x, x => _data.TargetFileRequested -= x); + }, x => _data.TargetFileRequested += x, x => _data.TargetFileRequested -= x); } } @@ -13614,9 +12318,7 @@ namespace Windows.Storage.Provider { void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, global::Windows.Storage.Provider.FileUpdateRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FileUpdateRequested += x, x => _data.FileUpdateRequested -= x); + }, x => _data.FileUpdateRequested += x, x => _data.FileUpdateRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13624,9 +12326,7 @@ namespace Windows.Storage.Provider { void Handler(global::Windows.Storage.Provider.CachedFileUpdaterUI sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UIRequested += x, x => _data.UIRequested -= x); + }, x => _data.UIRequested += x, x => _data.UIRequested -= x); } } @@ -13677,9 +12377,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13687,9 +12385,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } /// @@ -13714,9 +12410,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13724,9 +12418,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } /// @@ -13751,9 +12443,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13761,9 +12451,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } /// @@ -13788,9 +12476,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); + }, x => _data.ContentsChanged += x, x => _data.ContentsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13798,9 +12484,7 @@ namespace Windows.Storage.Search { void Handler(global::Windows.Storage.Search.IStorageQueryResultBase sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); + }, x => _data.OptionsChanged += x, x => _data.OptionsChanged -= x); } } @@ -13855,9 +12539,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13865,9 +12547,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13875,9 +12555,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, global::Windows.System.AppDiagnosticInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13885,9 +12563,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppDiagnosticInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -13912,9 +12588,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13922,9 +12596,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13932,9 +12604,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ExecutionStateChanged += x, x => _data.ExecutionStateChanged -= x); + }, x => _data.ExecutionStateChanged += x, x => _data.ExecutionStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13942,9 +12612,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, global::Windows.System.AppResourceGroupInfoWatcherEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13952,9 +12620,7 @@ namespace Windows.System { void Handler(global::Windows.System.AppResourceGroupInfoWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); } /// @@ -13979,9 +12645,7 @@ namespace Windows.System { void Handler(global::Windows.System.DispatcherQueue sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShutdownCompleted += x, x => _data.ShutdownCompleted -= x); + }, x => _data.ShutdownCompleted += x, x => _data.ShutdownCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -13989,9 +12653,7 @@ namespace Windows.System { void Handler(global::Windows.System.DispatcherQueue sender, global::Windows.System.DispatcherQueueShutdownStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ShutdownStarting += x, x => _data.ShutdownStarting -= x); + }, x => _data.ShutdownStarting += x, x => _data.ShutdownStarting -= x); } /// @@ -14016,9 +12678,7 @@ namespace Windows.System { void Handler(global::Windows.System.DispatcherQueueTimer sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// @@ -14043,9 +12703,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14053,9 +12711,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AuthenticationStatusChanged += x, x => _data.AuthenticationStatusChanged -= x); + }, x => _data.AuthenticationStatusChanged += x, x => _data.AuthenticationStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14063,9 +12719,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserAuthenticationStatusChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AuthenticationStatusChanging += x, x => _data.AuthenticationStatusChanging -= x); + }, x => _data.AuthenticationStatusChanging += x, x => _data.AuthenticationStatusChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14073,9 +12727,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14083,9 +12735,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14093,9 +12743,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Stopped += x, x => _data.Stopped -= x); + }, x => _data.Stopped += x, x => _data.Stopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14103,9 +12751,7 @@ namespace Windows.System { void Handler(global::Windows.System.UserWatcher sender, global::Windows.System.UserChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } } @@ -14144,9 +12790,7 @@ namespace Windows.System.Diagnostics.DevicePortal { void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14154,9 +12798,7 @@ namespace Windows.System.Diagnostics.DevicePortal { void Handler(global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnection sender, global::Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RequestReceived += x, x => _data.RequestReceived -= x); + }, x => _data.RequestReceived += x, x => _data.RequestReceived -= x); } } @@ -14195,9 +12837,7 @@ namespace Windows.System.Preview { void Handler(global::Windows.System.Preview.TwoPanelHingedDevicePosturePreview sender, global::Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PostureChanged += x, x => _data.PostureChanged -= x); + }, x => _data.PostureChanged += x, x => _data.PostureChanged -= x); } } @@ -14260,9 +12900,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSession sender, global::Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Disconnected += x, x => _data.Disconnected -= x); + }, x => _data.Disconnected += x, x => _data.Disconnected -= x); } /// @@ -14287,9 +12925,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionController sender, global::Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.JoinRequested += x, x => _data.JoinRequested -= x); + }, x => _data.JoinRequested += x, x => _data.JoinRequested -= x); } /// @@ -14314,9 +12950,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener sender, global::Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InvitationReceived += x, x => _data.InvitationReceived -= x); + }, x => _data.InvitationReceived += x, x => _data.InvitationReceived -= x); } /// @@ -14341,9 +12975,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel sender, global::Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValueSetReceived += x, x => _data.ValueSetReceived -= x); + }, x => _data.ValueSetReceived += x, x => _data.ValueSetReceived -= x); } /// @@ -14368,9 +13000,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14378,9 +13008,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14388,9 +13016,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); } /// @@ -14415,9 +13041,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Added += x, x => _data.Added -= x); + }, x => _data.Added += x, x => _data.Added -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14425,9 +13049,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Removed += x, x => _data.Removed -= x); + }, x => _data.Removed += x, x => _data.Removed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14435,9 +13057,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemSessionWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Updated += x, x => _data.Updated -= x); + }, x => _data.Updated += x, x => _data.Updated -= x); } /// @@ -14462,9 +13082,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); + }, x => _data.EnumerationCompleted += x, x => _data.EnumerationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14472,9 +13090,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14482,9 +13098,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemAddedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteSystemAdded += x, x => _data.RemoteSystemAdded -= x); + }, x => _data.RemoteSystemAdded += x, x => _data.RemoteSystemAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14492,9 +13106,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteSystemRemoved += x, x => _data.RemoteSystemRemoved -= x); + }, x => _data.RemoteSystemRemoved += x, x => _data.RemoteSystemRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14502,9 +13114,7 @@ namespace Windows.System.RemoteSystems { void Handler(global::Windows.System.RemoteSystems.RemoteSystemWatcher sender, global::Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RemoteSystemUpdated += x, x => _data.RemoteSystemUpdated -= x); + }, x => _data.RemoteSystemUpdated += x, x => _data.RemoteSystemUpdated -= x); } } @@ -14543,9 +13153,7 @@ namespace Windows.UI.Accessibility { void Handler(global::Windows.UI.Accessibility.ScreenReaderService sender, global::Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenReaderPositionChanged += x, x => _data.ScreenReaderPositionChanged -= x); + }, x => _data.ScreenReaderPositionChanged += x, x => _data.ScreenReaderPositionChanged -= x); } } @@ -14584,9 +13192,7 @@ namespace Windows.UI.ApplicationSettings { void Handler(global::Windows.UI.ApplicationSettings.AccountsSettingsPane sender, global::Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccountCommandsRequested += x, x => _data.AccountCommandsRequested -= x); + }, x => _data.AccountCommandsRequested += x, x => _data.AccountCommandsRequested -= x); } } @@ -14637,9 +13243,7 @@ namespace Windows.UI.Composition { void Handler(global::Windows.UI.Composition.CompositionCapabilities sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } /// @@ -14664,9 +13268,7 @@ namespace Windows.UI.Composition { void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -14691,9 +13293,7 @@ namespace Windows.UI.Composition { void Handler(global::Windows.UI.Composition.CompositionGraphicsDevice sender, global::Windows.UI.Composition.RenderingDeviceReplacedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RenderingDeviceReplaced += x, x => _data.RenderingDeviceReplaced -= x); + }, x => _data.RenderingDeviceReplaced += x, x => _data.RenderingDeviceReplaced -= x); } /// @@ -14718,9 +13318,7 @@ namespace Windows.UI.Composition { void Handler(object sender, global::Windows.UI.Composition.CompositionBatchCompletedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } } @@ -14759,9 +13357,7 @@ namespace Windows.UI.Composition.Core { void Handler(global::Windows.UI.Composition.Core.CompositorController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CommitNeeded += x, x => _data.CommitNeeded -= x); + }, x => _data.CommitNeeded += x, x => _data.CommitNeeded -= x); } } @@ -14840,9 +13436,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); } /// @@ -14867,9 +13461,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14877,9 +13469,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreComponentInputSource sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14887,9 +13477,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14897,9 +13485,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14907,9 +13493,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14917,9 +13501,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14927,9 +13509,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14937,9 +13517,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14947,9 +13525,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14957,9 +13533,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14967,9 +13541,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14977,9 +13549,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14987,9 +13557,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -14997,9 +13565,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15007,9 +13573,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); } /// @@ -15034,9 +13598,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); } /// @@ -15061,9 +13623,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15071,9 +13631,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15081,9 +13639,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15091,9 +13647,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15101,9 +13655,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15111,9 +13663,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15121,9 +13671,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15131,9 +13679,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); } /// @@ -15158,9 +13704,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15168,9 +13712,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15178,9 +13720,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15188,9 +13728,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15198,9 +13736,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); + }, x => _data.ClosestInteractiveBoundsRequested += x, x => _data.ClosestInteractiveBoundsRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15208,9 +13744,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15218,9 +13752,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15228,9 +13760,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15238,9 +13768,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15248,9 +13776,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15258,9 +13784,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15268,9 +13792,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15278,9 +13800,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15288,9 +13808,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15298,9 +13816,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15308,9 +13824,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15318,9 +13832,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15328,9 +13840,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15338,9 +13848,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResizeCompleted += x, x => _data.ResizeCompleted -= x); + }, x => _data.ResizeCompleted += x, x => _data.ResizeCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15348,9 +13856,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResizeStarted += x, x => _data.ResizeStarted -= x); + }, x => _data.ResizeStarted += x, x => _data.ResizeStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15358,9 +13864,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15368,9 +13872,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15378,9 +13880,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } /// @@ -15405,9 +13905,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreDispatcher sender, global::Windows.UI.Core.AcceleratorKeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); + }, x => _data.AcceleratorKeyActivated += x, x => _data.AcceleratorKeyActivated -= x); } /// @@ -15432,9 +13930,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); } /// @@ -15459,9 +13955,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15469,9 +13963,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15479,9 +13971,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15489,9 +13979,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15499,9 +13987,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15509,9 +13995,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15519,9 +14003,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); } /// @@ -15546,9 +14028,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); + }, x => _data.PointerRoutedAway += x, x => _data.PointerRoutedAway -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15556,9 +14036,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); + }, x => _data.PointerRoutedReleased += x, x => _data.PointerRoutedReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15566,9 +14044,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.ICorePointerRedirector sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); + }, x => _data.PointerRoutedTo += x, x => _data.PointerRoutedTo -= x); } /// @@ -15593,9 +14069,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15603,9 +14077,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.AutomationProviderRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); + }, x => _data.AutomationProviderRequested += x, x => _data.AutomationProviderRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15613,9 +14085,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CharacterReceivedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15623,9 +14093,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.CoreWindowEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15633,9 +14101,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.InputEnabledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputEnabled += x, x => _data.InputEnabled -= x); + }, x => _data.InputEnabled += x, x => _data.InputEnabled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15643,9 +14109,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15653,9 +14117,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15663,9 +14125,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15673,9 +14133,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15683,9 +14141,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15693,9 +14149,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15703,9 +14157,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15713,9 +14165,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15723,9 +14173,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15733,9 +14181,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.WindowSizeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15743,9 +14189,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.TouchHitTestingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); + }, x => _data.TouchHitTesting += x, x => _data.TouchHitTesting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15753,9 +14197,7 @@ namespace Windows.UI.Core { void Handler(global::Windows.UI.Core.CoreWindow sender, global::Windows.UI.Core.VisibilityChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } /// @@ -15780,9 +14222,7 @@ namespace Windows.UI.Core { void Handler(object sender, global::Windows.UI.Core.BackRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackRequested += x, x => _data.BackRequested -= x); + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); } } @@ -15821,9 +14261,7 @@ namespace Windows.UI.Core.Preview { void Handler(object sender, global::Windows.UI.Core.Preview.SystemNavigationCloseRequestedPreviewEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); } } @@ -15878,9 +14316,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15888,9 +14324,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15898,9 +14332,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.EdgeGesture sender, global::Windows.UI.Input.EdgeGestureEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Starting += x, x => _data.Starting -= x); + }, x => _data.Starting += x, x => _data.Starting -= x); } /// @@ -15925,9 +14357,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.CrossSlidingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CrossSliding += x, x => _data.CrossSliding -= x); + }, x => _data.CrossSliding += x, x => _data.CrossSliding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15935,9 +14365,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.DraggingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Dragging += x, x => _data.Dragging -= x); + }, x => _data.Dragging += x, x => _data.Dragging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15945,9 +14373,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.HoldingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Holding += x, x => _data.Holding -= x); + }, x => _data.Holding += x, x => _data.Holding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15955,9 +14381,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15965,9 +14389,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationInertiaStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15975,9 +14397,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15985,9 +14405,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.ManipulationUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -15995,9 +14413,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.RightTappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RightTapped += x, x => _data.RightTapped -= x); + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16005,9 +14421,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.GestureRecognizer sender, global::Windows.UI.Input.TappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -16032,9 +14446,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16042,9 +14454,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.KeyboardDeliveryInterceptor sender, global::Windows.UI.Core.KeyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); } /// @@ -16069,9 +14479,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonClickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonClicked += x, x => _data.ButtonClicked -= x); + }, x => _data.ButtonClicked += x, x => _data.ButtonClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16079,9 +14487,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonHoldingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonHolding += x, x => _data.ButtonHolding -= x); + }, x => _data.ButtonHolding += x, x => _data.ButtonHolding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16089,9 +14495,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonPressedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); + }, x => _data.ButtonPressed += x, x => _data.ButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16099,9 +14503,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerButtonReleasedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ButtonReleased += x, x => _data.ButtonReleased -= x); + }, x => _data.ButtonReleased += x, x => _data.ButtonReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16109,9 +14511,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerControlAcquiredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ControlAcquired += x, x => _data.ControlAcquired -= x); + }, x => _data.ControlAcquired += x, x => _data.ControlAcquired -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16119,9 +14519,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ControlLost += x, x => _data.ControlLost -= x); + }, x => _data.ControlLost += x, x => _data.ControlLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16129,9 +14527,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerRotationChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RotationChanged += x, x => _data.RotationChanged -= x); + }, x => _data.RotationChanged += x, x => _data.RotationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16139,9 +14535,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenContactContinued += x, x => _data.ScreenContactContinued -= x); + }, x => _data.ScreenContactContinued += x, x => _data.ScreenContactContinued -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16149,9 +14543,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenContactEnded += x, x => _data.ScreenContactEnded -= x); + }, x => _data.ScreenContactEnded += x, x => _data.ScreenContactEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16159,9 +14551,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialController sender, global::Windows.UI.Input.RadialControllerScreenContactStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScreenContactStarted += x, x => _data.ScreenContactStarted -= x); + }, x => _data.ScreenContactStarted += x, x => _data.ScreenContactStarted -= x); } /// @@ -16186,9 +14576,7 @@ namespace Windows.UI.Input { void Handler(global::Windows.UI.Input.RadialControllerMenuItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } } @@ -16235,9 +14623,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesCollectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokesCollected += x, x => _data.StrokesCollected -= x); + }, x => _data.StrokesCollected += x, x => _data.StrokesCollected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16245,9 +14631,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkPresenter sender, global::Windows.UI.Input.Inking.InkStrokesErasedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokesErased += x, x => _data.StrokesErased -= x); + }, x => _data.StrokesErased += x, x => _data.StrokesErased -= x); } /// @@ -16272,9 +14656,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeCanceled += x, x => _data.StrokeCanceled -= x); + }, x => _data.StrokeCanceled += x, x => _data.StrokeCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16282,9 +14664,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeContinued += x, x => _data.StrokeContinued -= x); + }, x => _data.StrokeContinued += x, x => _data.StrokeContinued -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16292,9 +14672,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeEnded += x, x => _data.StrokeEnded -= x); + }, x => _data.StrokeEnded += x, x => _data.StrokeEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16302,9 +14680,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkStrokeInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.StrokeStarted += x, x => _data.StrokeStarted -= x); + }, x => _data.StrokeStarted += x, x => _data.StrokeStarted -= x); } /// @@ -16329,9 +14705,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16339,9 +14713,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16349,9 +14721,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerHovered += x, x => _data.PointerHovered -= x); + }, x => _data.PointerHovered += x, x => _data.PointerHovered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16359,9 +14729,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerLost += x, x => _data.PointerLost -= x); + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16369,9 +14737,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16379,9 +14745,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16389,9 +14753,7 @@ namespace Windows.UI.Input.Inking { void Handler(global::Windows.UI.Input.Inking.InkUnprocessedInput sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); } } @@ -16434,9 +14796,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerEntering += x, x => _data.PointerEntering -= x); + }, x => _data.PointerEntering += x, x => _data.PointerEntering -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16444,9 +14804,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerExiting += x, x => _data.PointerExiting -= x); + }, x => _data.PointerExiting += x, x => _data.PointerExiting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16454,9 +14812,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerHovering += x, x => _data.PointerHovering -= x); + }, x => _data.PointerHovering += x, x => _data.PointerHovering -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16464,9 +14820,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerLost += x, x => _data.PointerLost -= x); + }, x => _data.PointerLost += x, x => _data.PointerLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16474,9 +14828,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerMoving += x, x => _data.PointerMoving -= x); + }, x => _data.PointerMoving += x, x => _data.PointerMoving -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16484,9 +14836,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerPressing += x, x => _data.PointerPressing -= x); + }, x => _data.PointerPressing += x, x => _data.PointerPressing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16494,9 +14844,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource sender, global::Windows.UI.Core.PointerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PointerReleasing += x, x => _data.PointerReleasing -= x); + }, x => _data.PointerReleasing += x, x => _data.PointerReleasing -= x); } /// @@ -16521,9 +14869,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeCanceled += x, x => _data.WetStrokeCanceled -= x); + }, x => _data.WetStrokeCanceled += x, x => _data.WetStrokeCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16531,9 +14877,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeCompleted += x, x => _data.WetStrokeCompleted -= x); + }, x => _data.WetStrokeCompleted += x, x => _data.WetStrokeCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16541,9 +14885,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeContinuing += x, x => _data.WetStrokeContinuing -= x); + }, x => _data.WetStrokeContinuing += x, x => _data.WetStrokeContinuing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16551,9 +14893,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeStarting += x, x => _data.WetStrokeStarting -= x); + }, x => _data.WetStrokeStarting += x, x => _data.WetStrokeStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16561,9 +14901,7 @@ namespace Windows.UI.Input.Inking.Core { void Handler(global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource sender, global::Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WetStrokeStopping += x, x => _data.WetStrokeStopping -= x); + }, x => _data.WetStrokeStopping += x, x => _data.WetStrokeStopping -= x); } } @@ -16606,9 +14944,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HoldCanceled += x, x => _data.HoldCanceled -= x); + }, x => _data.HoldCanceled += x, x => _data.HoldCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16616,9 +14952,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HoldCompleted += x, x => _data.HoldCompleted -= x); + }, x => _data.HoldCompleted += x, x => _data.HoldCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16626,9 +14960,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HoldStarted += x, x => _data.HoldStarted -= x); + }, x => _data.HoldStarted += x, x => _data.HoldStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16636,9 +14968,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationCanceled += x, x => _data.ManipulationCanceled -= x); + }, x => _data.ManipulationCanceled += x, x => _data.ManipulationCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16646,9 +14976,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16656,9 +14984,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16666,9 +14992,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); + }, x => _data.ManipulationUpdated += x, x => _data.ManipulationUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16676,9 +15000,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCanceled += x, x => _data.NavigationCanceled -= x); + }, x => _data.NavigationCanceled += x, x => _data.NavigationCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16686,9 +15008,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16696,9 +15016,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarted += x, x => _data.NavigationStarted -= x); + }, x => _data.NavigationStarted += x, x => _data.NavigationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16706,9 +15024,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationUpdated += x, x => _data.NavigationUpdated -= x); + }, x => _data.NavigationUpdated += x, x => _data.NavigationUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16716,9 +15032,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RecognitionEnded += x, x => _data.RecognitionEnded -= x); + }, x => _data.RecognitionEnded += x, x => _data.RecognitionEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16726,9 +15040,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RecognitionStarted += x, x => _data.RecognitionStarted -= x); + }, x => _data.RecognitionStarted += x, x => _data.RecognitionStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16736,9 +15048,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialGestureRecognizer sender, global::Windows.UI.Input.Spatial.SpatialTappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -16763,9 +15073,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InteractionDetected += x, x => _data.InteractionDetected -= x); + }, x => _data.InteractionDetected += x, x => _data.InteractionDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16773,9 +15081,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceDetected += x, x => _data.SourceDetected -= x); + }, x => _data.SourceDetected += x, x => _data.SourceDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16783,9 +15089,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceLost += x, x => _data.SourceLost -= x); + }, x => _data.SourceLost += x, x => _data.SourceLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16793,9 +15097,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourcePressed += x, x => _data.SourcePressed -= x); + }, x => _data.SourcePressed += x, x => _data.SourcePressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16803,9 +15105,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceReleased += x, x => _data.SourceReleased -= x); + }, x => _data.SourceReleased += x, x => _data.SourceReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16813,9 +15113,7 @@ namespace Windows.UI.Input.Spatial { void Handler(global::Windows.UI.Input.Spatial.SpatialInteractionManager sender, global::Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); + }, x => _data.SourceUpdated += x, x => _data.SourceUpdated -= x); } } @@ -16858,9 +15156,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotification sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16868,9 +15164,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastDismissedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -16878,9 +15172,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotification sender, global::Windows.UI.Notifications.ToastFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Failed += x, x => _data.Failed -= x); + }, x => _data.Failed += x, x => _data.Failed -= x); } /// @@ -16905,9 +15197,7 @@ namespace Windows.UI.Notifications { void Handler(global::Windows.UI.Notifications.ToastNotifier sender, global::Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScheduledToastNotificationShowing += x, x => _data.ScheduledToastNotificationShowing -= x); + }, x => _data.ScheduledToastNotificationShowing += x, x => _data.ScheduledToastNotificationShowing -= x); } } @@ -16946,9 +15236,7 @@ namespace Windows.UI.Notifications.Management { void Handler(global::Windows.UI.Notifications.Management.UserNotificationListener sender, global::Windows.UI.Notifications.UserNotificationChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NotificationChanged += x, x => _data.NotificationChanged -= x); + }, x => _data.NotificationChanged += x, x => _data.NotificationChanged -= x); } } @@ -16987,9 +15275,7 @@ namespace Windows.UI.StartScreen { void Handler(global::Windows.UI.StartScreen.SecondaryTile sender, global::Windows.UI.StartScreen.VisualElementsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisualElementsRequested += x, x => _data.VisualElementsRequested -= x); + }, x => _data.VisualElementsRequested += x, x => _data.VisualElementsRequested -= x); } } @@ -17032,9 +15318,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompositionCompleted += x, x => _data.CompositionCompleted -= x); + }, x => _data.CompositionCompleted += x, x => _data.CompositionCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17042,9 +15326,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompositionStarted += x, x => _data.CompositionStarted -= x); + }, x => _data.CompositionStarted += x, x => _data.CompositionStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17052,9 +15334,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusRemoved += x, x => _data.FocusRemoved -= x); + }, x => _data.FocusRemoved += x, x => _data.FocusRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17062,9 +15342,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FormatUpdating += x, x => _data.FormatUpdating -= x); + }, x => _data.FormatUpdating += x, x => _data.FormatUpdating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17072,9 +15350,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LayoutRequested += x, x => _data.LayoutRequested -= x); + }, x => _data.LayoutRequested += x, x => _data.LayoutRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17082,9 +15358,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NotifyFocusLeaveCompleted += x, x => _data.NotifyFocusLeaveCompleted -= x); + }, x => _data.NotifyFocusLeaveCompleted += x, x => _data.NotifyFocusLeaveCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17092,9 +15366,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionRequested += x, x => _data.SelectionRequested -= x); + }, x => _data.SelectionRequested += x, x => _data.SelectionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17102,9 +15374,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionUpdating += x, x => _data.SelectionUpdating -= x); + }, x => _data.SelectionUpdating += x, x => _data.SelectionUpdating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17112,9 +15382,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextRequested += x, x => _data.TextRequested -= x); + }, x => _data.TextRequested += x, x => _data.TextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17122,9 +15390,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextEditContext sender, global::Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextUpdating += x, x => _data.TextUpdating -= x); + }, x => _data.TextUpdating += x, x => _data.TextUpdating -= x); } /// @@ -17149,9 +15415,7 @@ namespace Windows.UI.Text.Core { void Handler(global::Windows.UI.Text.Core.CoreTextServicesManager sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); + }, x => _data.InputLanguageChanged += x, x => _data.InputLanguageChanged -= x); } } @@ -17206,9 +15470,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.AccessibilitySettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HighContrastChanged += x, x => _data.HighContrastChanged -= x); + }, x => _data.HighContrastChanged += x, x => _data.HighContrastChanged -= x); } /// @@ -17233,9 +15495,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, global::Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Consolidated += x, x => _data.Consolidated -= x); + }, x => _data.Consolidated += x, x => _data.Consolidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17243,9 +15503,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.ApplicationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.VisibleBoundsChanged += x, x => _data.VisibleBoundsChanged -= x); + }, x => _data.VisibleBoundsChanged += x, x => _data.VisibleBoundsChanged -= x); } /// @@ -17270,9 +15528,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Hiding += x, x => _data.Hiding -= x); + }, x => _data.Hiding += x, x => _data.Hiding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17280,9 +15536,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.InputPane sender, global::Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Showing += x, x => _data.Showing -= x); + }, x => _data.Showing += x, x => _data.Showing -= x); } /// @@ -17307,9 +15561,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Hiding += x, x => _data.Hiding -= x); + }, x => _data.Hiding += x, x => _data.Hiding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17317,9 +15569,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.StatusBar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Showing += x, x => _data.Showing -= x); + }, x => _data.Showing += x, x => _data.Showing -= x); } /// @@ -17344,9 +15594,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AdvancedEffectsEnabledChanged += x, x => _data.AdvancedEffectsEnabledChanged -= x); + }, x => _data.AdvancedEffectsEnabledChanged += x, x => _data.AdvancedEffectsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17354,9 +15602,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorValuesChanged += x, x => _data.ColorValuesChanged -= x); + }, x => _data.ColorValuesChanged += x, x => _data.ColorValuesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17364,9 +15610,7 @@ namespace Windows.UI.ViewManagement { void Handler(global::Windows.UI.ViewManagement.UISettings sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextScaleFactorChanged += x, x => _data.TextScaleFactorChanged -= x); + }, x => _data.TextScaleFactorChanged += x, x => _data.TextScaleFactorChanged -= x); } } @@ -17405,9 +15649,7 @@ namespace Windows.UI.ViewManagement.Core { void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OcclusionsChanged += x, x => _data.OcclusionsChanged -= x); + }, x => _data.OcclusionsChanged += x, x => _data.OcclusionsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17415,9 +15657,7 @@ namespace Windows.UI.ViewManagement.Core { void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.XYFocusTransferredToPrimaryView += x, x => _data.XYFocusTransferredToPrimaryView -= x); + }, x => _data.XYFocusTransferredToPrimaryView += x, x => _data.XYFocusTransferredToPrimaryView -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17425,9 +15665,7 @@ namespace Windows.UI.ViewManagement.Core { void Handler(global::Windows.UI.ViewManagement.Core.CoreInputView sender, global::Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.XYFocusTransferringFromPrimaryView += x, x => _data.XYFocusTransferringFromPrimaryView -= x); + }, x => _data.XYFocusTransferringFromPrimaryView += x, x => _data.XYFocusTransferringFromPrimaryView -= x); } } @@ -17470,9 +15708,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.ApplicationModel.Background.IBackgroundTaskInstance sender, global::Windows.ApplicationModel.Background.BackgroundTaskCancellationReason reason) => eventHandler((sender, reason)); return Handler; - } - - , x => _data.Canceled += x, x => _data.Canceled -= x); + }, x => _data.Canceled += x, x => _data.Canceled -= x); } /// @@ -17497,9 +15733,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.UI.WebUI.WebUIView sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17507,9 +15741,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.UI.WebUI.WebUIView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17517,9 +15749,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17527,9 +15757,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17537,9 +15765,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17547,9 +15773,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17557,9 +15781,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17567,9 +15789,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17577,9 +15797,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17587,9 +15805,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17597,9 +15813,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17607,9 +15821,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17617,9 +15829,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17627,9 +15837,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17637,9 +15845,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17647,9 +15853,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17657,9 +15861,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17667,9 +15869,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17677,9 +15877,7 @@ namespace Windows.UI.WebUI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } } @@ -17798,9 +15996,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EnteredBackground += x, x => _data.EnteredBackground -= x); + }, x => _data.EnteredBackground += x, x => _data.EnteredBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17808,9 +16004,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LeavingBackground += x, x => _data.LeavingBackground -= x); + }, x => _data.LeavingBackground += x, x => _data.LeavingBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17818,9 +16012,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Resuming += x, x => _data.Resuming -= x); + }, x => _data.Resuming += x, x => _data.Resuming -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17828,9 +16020,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Suspending += x, x => _data.Suspending -= x); + }, x => _data.Suspending += x, x => _data.Suspending -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17838,9 +16028,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.UnhandledExceptionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UnhandledException += x, x => _data.UnhandledException -= x); + }, x => _data.UnhandledException += x, x => _data.UnhandledException -= x); } /// @@ -17865,9 +16053,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -17892,9 +16078,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.BindingFailedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingFailed += x, x => _data.BindingFailed -= x); + }, x => _data.BindingFailed += x, x => _data.BindingFailed -= x); } /// @@ -17919,9 +16103,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -17946,9 +16128,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Tick += x, x => _data.Tick -= x); + }, x => _data.Tick += x, x => _data.Tick -= x); } /// @@ -17973,9 +16153,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.FrameworkElement sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActualThemeChanged += x, x => _data.ActualThemeChanged -= x); + }, x => _data.ActualThemeChanged += x, x => _data.ActualThemeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17983,9 +16161,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.FrameworkElement sender, global::Windows.UI.Xaml.EffectiveViewportChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EffectiveViewportChanged += x, x => _data.EffectiveViewportChanged -= x); + }, x => _data.EffectiveViewportChanged += x, x => _data.EffectiveViewportChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -17993,9 +16169,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18003,9 +16177,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18013,9 +16185,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18023,9 +16193,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18033,9 +16201,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18043,9 +16209,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -18070,9 +16234,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18097,9 +16259,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18107,9 +16267,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18117,9 +16275,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18127,9 +16283,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -18154,9 +16308,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18181,9 +16333,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18208,9 +16358,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18235,9 +16383,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18262,9 +16408,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18289,9 +16433,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18316,9 +16458,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18343,9 +16483,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18353,9 +16491,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18363,9 +16499,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18373,9 +16507,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.BringIntoViewRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BringIntoViewRequested += x, x => _data.BringIntoViewRequested -= x); + }, x => _data.BringIntoViewRequested += x, x => _data.BringIntoViewRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18383,9 +16515,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); + }, x => _data.CharacterReceived += x, x => _data.CharacterReceived -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18393,9 +16523,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContextCanceled += x, x => _data.ContextCanceled -= x); + }, x => _data.ContextCanceled += x, x => _data.ContextCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18403,9 +16531,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContextRequested += x, x => _data.ContextRequested -= x); + }, x => _data.ContextRequested += x, x => _data.ContextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18413,9 +16539,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); + }, x => _data.DoubleTapped += x, x => _data.DoubleTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18423,9 +16547,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragEnter += x, x => _data.DragEnter -= x); + }, x => _data.DragEnter += x, x => _data.DragEnter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18433,9 +16555,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragLeave += x, x => _data.DragLeave -= x); + }, x => _data.DragLeave += x, x => _data.DragLeave -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18443,9 +16563,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragOver += x, x => _data.DragOver -= x); + }, x => _data.DragOver += x, x => _data.DragOver -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18453,9 +16571,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DragStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragStarting += x, x => _data.DragStarting -= x); + }, x => _data.DragStarting += x, x => _data.DragStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18463,9 +16579,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drop += x, x => _data.Drop -= x); + }, x => _data.Drop += x, x => _data.Drop -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18473,9 +16587,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.DropCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DropCompleted += x, x => _data.DropCompleted -= x); + }, x => _data.DropCompleted += x, x => _data.DropCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18483,9 +16595,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GettingFocus += x, x => _data.GettingFocus -= x); + }, x => _data.GettingFocus += x, x => _data.GettingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18493,9 +16603,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18503,9 +16611,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.HoldingRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Holding += x, x => _data.Holding -= x); + }, x => _data.Holding += x, x => _data.Holding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18513,9 +16619,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18523,9 +16627,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18533,9 +16635,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LosingFocus += x, x => _data.LosingFocus -= x); + }, x => _data.LosingFocus += x, x => _data.LosingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18543,9 +16643,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18553,9 +16651,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); + }, x => _data.ManipulationCompleted += x, x => _data.ManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18563,9 +16659,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); + }, x => _data.ManipulationDelta += x, x => _data.ManipulationDelta -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18573,9 +16667,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); + }, x => _data.ManipulationInertiaStarting += x, x => _data.ManipulationInertiaStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18583,9 +16675,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); + }, x => _data.ManipulationStarted += x, x => _data.ManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18593,9 +16683,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); + }, x => _data.ManipulationStarting += x, x => _data.ManipulationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18603,9 +16691,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NoFocusCandidateFound += x, x => _data.NoFocusCandidateFound -= x); + }, x => _data.NoFocusCandidateFound += x, x => _data.NoFocusCandidateFound -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18613,9 +16699,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerCanceled += x, x => _data.PointerCanceled -= x); + }, x => _data.PointerCanceled += x, x => _data.PointerCanceled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18623,9 +16707,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); + }, x => _data.PointerCaptureLost += x, x => _data.PointerCaptureLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18633,9 +16715,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerEntered += x, x => _data.PointerEntered -= x); + }, x => _data.PointerEntered += x, x => _data.PointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18643,9 +16723,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerExited += x, x => _data.PointerExited -= x); + }, x => _data.PointerExited += x, x => _data.PointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18653,9 +16731,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerMoved += x, x => _data.PointerMoved -= x); + }, x => _data.PointerMoved += x, x => _data.PointerMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18663,9 +16739,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerPressed += x, x => _data.PointerPressed -= x); + }, x => _data.PointerPressed += x, x => _data.PointerPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18673,9 +16747,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerReleased += x, x => _data.PointerReleased -= x); + }, x => _data.PointerReleased += x, x => _data.PointerReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18683,9 +16755,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); + }, x => _data.PointerWheelChanged += x, x => _data.PointerWheelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18693,9 +16763,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); + }, x => _data.PreviewKeyDown += x, x => _data.PreviewKeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18703,9 +16771,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); + }, x => _data.PreviewKeyUp += x, x => _data.PreviewKeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18713,9 +16779,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.UIElement sender, global::Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProcessKeyboardAccelerators += x, x => _data.ProcessKeyboardAccelerators -= x); + }, x => _data.ProcessKeyboardAccelerators += x, x => _data.ProcessKeyboardAccelerators -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18723,9 +16787,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.RightTappedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RightTapped += x, x => _data.RightTapped -= x); + }, x => _data.RightTapped += x, x => _data.RightTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18733,9 +16795,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.Input.TappedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -18760,9 +16820,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18787,9 +16845,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18797,9 +16853,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Xaml.VisualStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); + }, x => _data.CurrentStateChanging += x, x => _data.CurrentStateChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18807,9 +16861,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18834,9 +16886,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18861,9 +16911,7 @@ namespace Windows.UI.Xaml { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -18888,9 +16936,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.WindowActivatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18898,9 +16944,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.CoreWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18908,9 +16952,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.WindowSizeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -18918,9 +16960,7 @@ namespace Windows.UI.Xaml { void Handler(object sender, global::Windows.UI.Core.VisibilityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); + }, x => _data.VisibilityChanged += x, x => _data.VisibilityChanged -= x); } } @@ -18959,9 +16999,7 @@ namespace Windows.UI.Xaml.Automation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -19004,9 +17042,7 @@ namespace Windows.UI.Xaml.Automation.Peers { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19031,9 +17067,7 @@ namespace Windows.UI.Xaml.Automation.Peers { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -19072,9 +17106,7 @@ namespace Windows.UI.Xaml.Automation.Provider { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -19437,9 +17469,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19447,9 +17477,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19457,9 +17485,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19467,9 +17493,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opening += x, x => _data.Opening -= x); + }, x => _data.Opening += x, x => _data.Opening -= x); } /// @@ -19494,9 +17518,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19504,9 +17526,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SuggestionChosen += x, x => _data.SuggestionChosen -= x); + }, x => _data.SuggestionChosen += x, x => _data.SuggestionChosen -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19514,9 +17534,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.AutoSuggestBox sender, global::Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -19541,9 +17559,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19568,9 +17584,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19595,9 +17609,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19622,9 +17634,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs e) => eventHandler((sender, e)); return Handler; - } - - , x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19632,9 +17642,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19642,9 +17650,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarDatePicker sender, global::Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DateChanged += x, x => _data.DateChanged -= x); + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19652,9 +17658,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -19679,9 +17683,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); + }, x => _data.CalendarViewDayItemChanging += x, x => _data.CalendarViewDayItemChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19689,9 +17691,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CalendarView sender, global::Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); + }, x => _data.SelectedDatesChanged += x, x => _data.SelectedDatesChanged -= x); } /// @@ -19716,9 +17716,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ColorPicker sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); } /// @@ -19743,9 +17741,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19770,9 +17766,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); + }, x => _data.DropDownClosed += x, x => _data.DropDownClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19780,9 +17774,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); + }, x => _data.DropDownOpened += x, x => _data.DropDownOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19790,9 +17782,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ComboBox sender, global::Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextSubmitted += x, x => _data.TextSubmitted -= x); + }, x => _data.TextSubmitted += x, x => _data.TextSubmitted -= x); } /// @@ -19817,9 +17807,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.CommandBar sender, global::Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DynamicOverflowItemsChanging += x, x => _data.DynamicOverflowItemsChanging -= x); + }, x => _data.DynamicOverflowItemsChanging += x, x => _data.DynamicOverflowItemsChanging -= x); } /// @@ -19844,9 +17832,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CloseButtonClick += x, x => _data.CloseButtonClick -= x); + }, x => _data.CloseButtonClick += x, x => _data.CloseButtonClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19854,9 +17840,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19864,9 +17848,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19874,9 +17856,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19884,9 +17864,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrimaryButtonClick += x, x => _data.PrimaryButtonClick -= x); + }, x => _data.PrimaryButtonClick += x, x => _data.PrimaryButtonClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19894,9 +17872,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ContentDialog sender, global::Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SecondaryButtonClick += x, x => _data.SecondaryButtonClick -= x); + }, x => _data.SecondaryButtonClick += x, x => _data.SecondaryButtonClick -= x); } /// @@ -19921,9 +17897,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusDisengaged += x, x => _data.FocusDisengaged -= x); + }, x => _data.FocusDisengaged += x, x => _data.FocusDisengaged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19931,9 +17905,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Control sender, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FocusEngaged += x, x => _data.FocusEngaged -= x); + }, x => _data.FocusEngaged += x, x => _data.FocusEngaged -= x); } /// @@ -19958,9 +17930,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -19985,9 +17955,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateChanged += x, x => _data.DateChanged -= x); + }, x => _data.DateChanged += x, x => _data.DateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -19995,9 +17963,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.DatePicker sender, global::Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); + }, x => _data.SelectedDateChanged += x, x => _data.SelectedDateChanged -= x); } /// @@ -20022,9 +17988,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.DatePickerFlyout sender, global::Windows.UI.Xaml.Controls.DatePickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DatePicked += x, x => _data.DatePicked -= x); + }, x => _data.DatePicked += x, x => _data.DatePicked -= x); } /// @@ -20049,9 +18013,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20076,9 +18038,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20086,9 +18046,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20096,9 +18054,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationFailedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20106,9 +18062,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); + }, x => _data.NavigationStopped += x, x => _data.NavigationStopped -= x); } /// @@ -20133,9 +18087,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -20160,9 +18112,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20170,9 +18120,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.HandwritingView sender, global::Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -20197,9 +18145,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.HubSectionHeaderClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SectionHeaderClick += x, x => _data.SectionHeaderClick -= x); + }, x => _data.SectionHeaderClick += x, x => _data.SectionHeaderClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20207,9 +18153,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SectionsInViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SectionsInViewChanged += x, x => _data.SectionsInViewChanged -= x); + }, x => _data.SectionsInViewChanged += x, x => _data.SectionsInViewChanged -= x); } /// @@ -20234,9 +18178,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20261,9 +18203,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20271,9 +18211,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20281,9 +18219,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20291,9 +18227,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20301,9 +18235,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20311,9 +18243,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20321,9 +18251,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20331,9 +18259,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20341,9 +18267,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -20368,9 +18292,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActiveToolChanged += x, x => _data.ActiveToolChanged -= x); + }, x => _data.ActiveToolChanged += x, x => _data.ActiveToolChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20378,9 +18300,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.EraseAllClicked += x, x => _data.EraseAllClicked -= x); + }, x => _data.EraseAllClicked += x, x => _data.EraseAllClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20388,9 +18308,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.InkDrawingAttributesChanged += x, x => _data.InkDrawingAttributesChanged -= x); + }, x => _data.InkDrawingAttributesChanged += x, x => _data.InkDrawingAttributesChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20398,9 +18316,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsRulerButtonCheckedChanged += x, x => _data.IsRulerButtonCheckedChanged -= x); + }, x => _data.IsRulerButtonCheckedChanged += x, x => _data.IsRulerButtonCheckedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20408,9 +18324,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbar sender, global::Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsStencilButtonCheckedChanged += x, x => _data.IsStencilButtonCheckedChanged -= x); + }, x => _data.IsStencilButtonCheckedChanged += x, x => _data.IsStencilButtonCheckedChanged -= x); } /// @@ -20435,9 +18349,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20462,9 +18374,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Checked += x, x => _data.Checked -= x); + }, x => _data.Checked += x, x => _data.Checked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20472,9 +18382,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.InkToolbarFlyoutItem sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Unchecked += x, x => _data.Unchecked -= x); + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); } /// @@ -20499,9 +18407,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20509,9 +18415,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -20536,9 +18440,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -20563,9 +18465,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.Foundation.Collections.IObservableVector sender, global::Windows.Foundation.Collections.IVectorChangedEventArgs @event) => eventHandler((sender, @event)); return Handler; - } - - , x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); } /// @@ -20590,9 +18490,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); + }, x => _data.ItemsChanged += x, x => _data.ItemsChanged -= x); } /// @@ -20617,9 +18515,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -20644,9 +18540,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20654,9 +18548,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -20681,9 +18573,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListPickerFlyout sender, global::Windows.UI.Xaml.Controls.ItemsPickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemsPicked += x, x => _data.ItemsPicked -= x); + }, x => _data.ItemsPicked += x, x => _data.ItemsPicked -= x); } /// @@ -20708,9 +18598,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ChoosingGroupHeaderContainer += x, x => _data.ChoosingGroupHeaderContainer -= x); + }, x => _data.ChoosingGroupHeaderContainer += x, x => _data.ChoosingGroupHeaderContainer -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20718,9 +18606,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ChoosingItemContainer += x, x => _data.ChoosingItemContainer -= x); + }, x => _data.ChoosingItemContainer += x, x => _data.ChoosingItemContainer -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20728,9 +18614,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainerContentChanging += x, x => _data.ContainerContentChanging -= x); + }, x => _data.ContainerContentChanging += x, x => _data.ContainerContentChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20738,9 +18622,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ListViewBase sender, global::Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20748,9 +18630,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.DragItemsStartingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20758,9 +18638,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ItemClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemClick += x, x => _data.ItemClick -= x); + }, x => _data.ItemClick += x, x => _data.ItemClick -= x); } /// @@ -20785,9 +18663,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); + }, x => _data.BufferingProgressChanged += x, x => _data.BufferingProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20795,9 +18671,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); + }, x => _data.CurrentStateChanged += x, x => _data.CurrentStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20805,9 +18679,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); + }, x => _data.DownloadProgressChanged += x, x => _data.DownloadProgressChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20815,9 +18687,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Media.TimelineMarkerRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MarkerReached += x, x => _data.MarkerReached -= x); + }, x => _data.MarkerReached += x, x => _data.MarkerReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20825,9 +18695,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20835,9 +18703,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20845,9 +18711,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20855,9 +18719,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.MediaElement sender, global::Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PartialMediaFailureDetected += x, x => _data.PartialMediaFailureDetected -= x); + }, x => _data.PartialMediaFailureDetected += x, x => _data.PartialMediaFailureDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20865,9 +18727,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Media.RateChangedRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RateChanged += x, x => _data.RateChanged -= x); + }, x => _data.RateChanged += x, x => _data.RateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20875,9 +18735,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20885,9 +18743,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); + }, x => _data.VolumeChanged += x, x => _data.VolumeChanged -= x); } /// @@ -20912,9 +18768,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.MediaTransportControls sender, global::Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ThumbnailRequested += x, x => _data.ThumbnailRequested -= x); + }, x => _data.ThumbnailRequested += x, x => _data.ThumbnailRequested -= x); } /// @@ -20939,9 +18793,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -20966,9 +18818,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20976,9 +18826,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20986,9 +18834,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -20996,9 +18842,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21006,9 +18850,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21016,9 +18858,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21026,9 +18866,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -21053,9 +18891,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21063,9 +18899,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21073,9 +18907,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21083,9 +18915,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21093,9 +18923,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21103,9 +18931,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21113,9 +18939,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21123,9 +18947,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21133,9 +18955,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -21160,9 +18980,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BackRequested += x, x => _data.BackRequested -= x); + }, x => _data.BackRequested += x, x => _data.BackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21170,9 +18988,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); + }, x => _data.DisplayModeChanged += x, x => _data.DisplayModeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21180,9 +18996,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21190,9 +19004,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21200,9 +19012,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21210,9 +19020,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21220,9 +19028,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21230,9 +19036,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.NavigationView sender, global::Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -21257,9 +19061,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21284,9 +19086,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21294,9 +19094,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); + }, x => _data.PasswordChanged += x, x => _data.PasswordChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21304,9 +19102,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.PasswordBox sender, global::Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PasswordChanging += x, x => _data.PasswordChanging -= x); + }, x => _data.PasswordChanging += x, x => _data.PasswordChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21314,9 +19110,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paste += x, x => _data.Paste -= x); + }, x => _data.Paste += x, x => _data.Paste -= x); } /// @@ -21341,9 +19135,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21351,9 +19143,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21361,9 +19151,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21371,9 +19159,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21381,9 +19167,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21391,9 +19175,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21401,9 +19183,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21411,9 +19191,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -21438,9 +19216,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21465,9 +19241,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.PickerFlyout sender, global::Windows.UI.Xaml.Controls.PickerConfirmedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Confirmed += x, x => _data.Confirmed -= x); + }, x => _data.Confirmed += x, x => _data.Confirmed -= x); } /// @@ -21492,9 +19266,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemLoaded += x, x => _data.PivotItemLoaded -= x); + }, x => _data.PivotItemLoaded += x, x => _data.PivotItemLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21502,9 +19274,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemLoading += x, x => _data.PivotItemLoading -= x); + }, x => _data.PivotItemLoading += x, x => _data.PivotItemLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21512,9 +19282,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemUnloaded += x, x => _data.PivotItemUnloaded -= x); + }, x => _data.PivotItemUnloaded += x, x => _data.PivotItemUnloaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21522,9 +19290,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.Pivot sender, global::Windows.UI.Xaml.Controls.PivotItemEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PivotItemUnloading += x, x => _data.PivotItemUnloading -= x); + }, x => _data.PivotItemUnloading += x, x => _data.PivotItemUnloading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21532,9 +19298,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -21559,9 +19323,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21569,9 +19331,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -21596,9 +19356,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21606,9 +19364,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21616,9 +19372,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21626,9 +19380,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21636,9 +19388,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21646,9 +19396,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -21673,9 +19421,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RatingControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -21700,9 +19446,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -21727,9 +19471,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RefreshContainer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); } /// @@ -21754,9 +19496,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); + }, x => _data.RefreshRequested += x, x => _data.RefreshRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21764,9 +19504,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RefreshVisualizer sender, global::Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.RefreshStateChanged += x, x => _data.RefreshStateChanged -= x); + }, x => _data.RefreshStateChanged += x, x => _data.RefreshStateChanged -= x); } /// @@ -21791,9 +19529,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21801,9 +19537,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLinkChanged += x, x => _data.ContentLinkChanged -= x); + }, x => _data.ContentLinkChanged += x, x => _data.ContentLinkChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21811,9 +19545,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLinkInvoked += x, x => _data.ContentLinkInvoked -= x); + }, x => _data.ContentLinkInvoked += x, x => _data.ContentLinkInvoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21821,9 +19553,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21831,9 +19561,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21841,9 +19569,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21851,9 +19577,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paste += x, x => _data.Paste -= x); + }, x => _data.Paste += x, x => _data.Paste -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21861,9 +19585,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21871,9 +19593,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21881,9 +19601,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21891,9 +19609,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextChanging += x, x => _data.TextChanging -= x); + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21901,9 +19617,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21911,9 +19625,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21921,9 +19633,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichEditBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); } /// @@ -21948,9 +19658,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21958,9 +19666,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichTextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -21968,9 +19674,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -21995,9 +19699,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.RichTextBlockOverflow sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); } /// @@ -22022,9 +19724,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22049,9 +19749,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22059,9 +19757,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22069,9 +19765,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22079,9 +19773,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22089,9 +19781,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22099,9 +19789,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22109,9 +19797,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -22136,9 +19822,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ScrollViewer sender, global::Windows.UI.Xaml.Controls.AnchorRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AnchorRequested += x, x => _data.AnchorRequested -= x); + }, x => _data.AnchorRequested += x, x => _data.AnchorRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22146,9 +19830,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DirectManipulationCompleted += x, x => _data.DirectManipulationCompleted -= x); + }, x => _data.DirectManipulationCompleted += x, x => _data.DirectManipulationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22156,9 +19838,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.DirectManipulationStarted += x, x => _data.DirectManipulationStarted -= x); + }, x => _data.DirectManipulationStarted += x, x => _data.DirectManipulationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22166,9 +19846,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChanged += x, x => _data.ViewChanged -= x); + }, x => _data.ViewChanged += x, x => _data.ViewChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22176,9 +19854,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChanging += x, x => _data.ViewChanging -= x); + }, x => _data.ViewChanging += x, x => _data.ViewChanging -= x); } /// @@ -22203,9 +19879,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.RoutedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PrepareForFocusOnKeyboardInput += x, x => _data.PrepareForFocusOnKeyboardInput -= x); + }, x => _data.PrepareForFocusOnKeyboardInput += x, x => _data.PrepareForFocusOnKeyboardInput -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22213,9 +19887,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QueryChanged += x, x => _data.QueryChanged -= x); + }, x => _data.QueryChanged += x, x => _data.QueryChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22223,9 +19895,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); + }, x => _data.QuerySubmitted += x, x => _data.QuerySubmitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22233,9 +19903,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); + }, x => _data.ResultSuggestionChosen += x, x => _data.ResultSuggestionChosen -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22243,9 +19911,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SearchBox sender, global::Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); + }, x => _data.SuggestionsRequested += x, x => _data.SuggestionsRequested -= x); } /// @@ -22270,9 +19936,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChangeCompleted += x, x => _data.ViewChangeCompleted -= x); + }, x => _data.ViewChangeCompleted += x, x => _data.ViewChangeCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22280,9 +19944,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewChangeStarted += x, x => _data.ViewChangeStarted -= x); + }, x => _data.ViewChangeStarted += x, x => _data.ViewChangeStarted -= x); } /// @@ -22307,9 +19969,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.BackClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackClick += x, x => _data.BackClick -= x); + }, x => _data.BackClick += x, x => _data.BackClick -= x); } /// @@ -22334,9 +19994,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22344,9 +20002,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); + }, x => _data.IsEnabledChanged += x, x => _data.IsEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22354,9 +20010,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22364,9 +20018,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Loaded += x, x => _data.Loaded -= x); + }, x => _data.Loaded += x, x => _data.Loaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22374,9 +20026,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Loading += x, x => _data.Loading -= x); + }, x => _data.Loading += x, x => _data.Loading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22384,9 +20034,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.SizeChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22394,9 +20042,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unloaded += x, x => _data.Unloaded -= x); + }, x => _data.Unloaded += x, x => _data.Unloaded -= x); } /// @@ -22421,9 +20067,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitButton sender, global::Windows.UI.Xaml.Controls.SplitButtonClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -22448,9 +20092,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosed += x, x => _data.PaneClosed -= x); + }, x => _data.PaneClosed += x, x => _data.PaneClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22458,9 +20100,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, global::Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneClosing += x, x => _data.PaneClosing -= x); + }, x => _data.PaneClosing += x, x => _data.PaneClosing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22468,9 +20108,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpened += x, x => _data.PaneOpened -= x); + }, x => _data.PaneOpened += x, x => _data.PaneOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22478,9 +20116,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SplitView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PaneOpening += x, x => _data.PaneOpening -= x); + }, x => _data.PaneOpening += x, x => _data.PaneOpening -= x); } /// @@ -22505,9 +20141,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22515,9 +20149,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -22542,9 +20174,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SwapChainPanel sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CompositionScaleChanged += x, x => _data.CompositionScaleChanged -= x); + }, x => _data.CompositionScaleChanged += x, x => _data.CompositionScaleChanged -= x); } /// @@ -22569,9 +20199,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22579,9 +20207,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.SwipeItem sender, global::Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -22606,9 +20232,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22633,9 +20257,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22643,9 +20265,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBlock sender, global::Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); + }, x => _data.IsTextTrimmedChanged += x, x => _data.IsTextTrimmedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22653,9 +20273,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -22680,9 +20298,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BeforeTextChanging += x, x => _data.BeforeTextChanging -= x); + }, x => _data.BeforeTextChanging += x, x => _data.BeforeTextChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22690,9 +20306,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); + }, x => _data.CandidateWindowBoundsChanged += x, x => _data.CandidateWindowBoundsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22700,9 +20314,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); + }, x => _data.ContextMenuOpening += x, x => _data.ContextMenuOpening -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22710,9 +20322,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); + }, x => _data.CopyingToClipboard += x, x => _data.CopyingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22720,9 +20330,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); + }, x => _data.CuttingToClipboard += x, x => _data.CuttingToClipboard -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22730,9 +20338,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paste += x, x => _data.Paste -= x); + }, x => _data.Paste += x, x => _data.Paste -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22740,9 +20346,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22750,9 +20354,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); + }, x => _data.SelectionChanging += x, x => _data.SelectionChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22760,9 +20362,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22770,9 +20370,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextChanging += x, x => _data.TextChanging -= x); + }, x => _data.TextChanging += x, x => _data.TextChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22780,9 +20378,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); + }, x => _data.TextCompositionChanged += x, x => _data.TextCompositionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22790,9 +20386,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); + }, x => _data.TextCompositionEnded += x, x => _data.TextCompositionEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22800,9 +20394,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TextBox sender, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); + }, x => _data.TextCompositionStarted += x, x => _data.TextCompositionStarted -= x); } /// @@ -22827,9 +20419,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -22854,9 +20444,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TimePicker sender, global::Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SelectedTimeChanged += x, x => _data.SelectedTimeChanged -= x); + }, x => _data.SelectedTimeChanged += x, x => _data.SelectedTimeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22864,9 +20452,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TimeChanged += x, x => _data.TimeChanged -= x); + }, x => _data.TimeChanged += x, x => _data.TimeChanged -= x); } /// @@ -22891,9 +20477,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TimePickerFlyout sender, global::Windows.UI.Xaml.Controls.TimePickedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TimePicked += x, x => _data.TimePicked -= x); + }, x => _data.TimePicked += x, x => _data.TimePicked -= x); } /// @@ -22918,9 +20502,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.ToggleSplitButton sender, global::Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.IsCheckedChanged += x, x => _data.IsCheckedChanged -= x); + }, x => _data.IsCheckedChanged += x, x => _data.IsCheckedChanged -= x); } /// @@ -22945,9 +20527,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -22972,9 +20552,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -22982,9 +20560,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -23009,9 +20585,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Collapsed += x, x => _data.Collapsed -= x); + }, x => _data.Collapsed += x, x => _data.Collapsed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23019,9 +20593,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); + }, x => _data.DragItemsCompleted += x, x => _data.DragItemsCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23029,9 +20601,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); + }, x => _data.DragItemsStarting += x, x => _data.DragItemsStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23039,9 +20609,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Expanding += x, x => _data.Expanding -= x); + }, x => _data.Expanding += x, x => _data.Expanding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23049,9 +20617,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.TreeView sender, global::Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); + }, x => _data.ItemInvoked += x, x => _data.ItemInvoked -= x); } /// @@ -23076,9 +20642,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23103,9 +20667,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23130,9 +20692,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23140,9 +20700,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23150,9 +20708,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -23177,9 +20733,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CleanUpVirtualizedItemEvent += x, x => _data.CleanUpVirtualizedItemEvent -= x); + }, x => _data.CleanUpVirtualizedItemEvent += x, x => _data.CleanUpVirtualizedItemEvent -= x); } /// @@ -23204,9 +20758,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23214,9 +20766,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23224,9 +20774,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23234,9 +20782,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23244,9 +20790,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23254,9 +20798,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23264,9 +20806,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23274,9 +20814,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Navigation.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23284,9 +20822,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23294,9 +20830,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23304,9 +20838,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.WebViewNavigationFailedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); + }, x => _data.NavigationFailed += x, x => _data.NavigationFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23314,9 +20846,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23324,9 +20854,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23334,9 +20862,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23344,9 +20870,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(object sender, global::Windows.UI.Xaml.Controls.NotifyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23354,9 +20878,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.SeparateProcessLost += x, x => _data.SeparateProcessLost -= x); + }, x => _data.SeparateProcessLost += x, x => _data.SeparateProcessLost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23364,9 +20886,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23374,9 +20894,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23384,9 +20902,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23394,9 +20910,7 @@ namespace Windows.UI.Xaml.Controls { void Handler(global::Windows.UI.Xaml.Controls.WebView sender, global::Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } } @@ -23503,9 +21017,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); + }, x => _data.BitmapRequested += x, x => _data.BitmapRequested -= x); } /// @@ -23530,9 +21042,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UriRequested += x, x => _data.UriRequested -= x); + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); } /// @@ -23557,9 +21067,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource sender, global::Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UriRequested += x, x => _data.UriRequested -= x); + }, x => _data.UriRequested += x, x => _data.UriRequested -= x); } /// @@ -23584,9 +21092,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23611,9 +21117,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActualCameraChanged += x, x => _data.ActualCameraChanged -= x); + }, x => _data.ActualCameraChanged += x, x => _data.ActualCameraChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23621,9 +21125,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ActualCameraChanging += x, x => _data.ActualCameraChanging -= x); + }, x => _data.ActualCameraChanging += x, x => _data.ActualCameraChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23631,9 +21133,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CenterChanged += x, x => _data.CenterChanged -= x); + }, x => _data.CenterChanged += x, x => _data.CenterChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23641,9 +21141,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CustomExperienceChanged += x, x => _data.CustomExperienceChanged -= x); + }, x => _data.CustomExperienceChanged += x, x => _data.CustomExperienceChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23651,9 +21149,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.HeadingChanged += x, x => _data.HeadingChanged -= x); + }, x => _data.HeadingChanged += x, x => _data.HeadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23661,9 +21157,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoadingStatusChanged += x, x => _data.LoadingStatusChanged -= x); + }, x => _data.LoadingStatusChanged += x, x => _data.LoadingStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23671,9 +21165,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23681,9 +21173,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapDoubleTapped += x, x => _data.MapDoubleTapped -= x); + }, x => _data.MapDoubleTapped += x, x => _data.MapDoubleTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23691,9 +21181,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23701,9 +21189,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23711,9 +21197,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23721,9 +21205,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapHolding += x, x => _data.MapHolding -= x); + }, x => _data.MapHolding += x, x => _data.MapHolding -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23731,9 +21213,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapRightTapped += x, x => _data.MapRightTapped -= x); + }, x => _data.MapRightTapped += x, x => _data.MapRightTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23741,9 +21221,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapInputEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapTapped += x, x => _data.MapTapped -= x); + }, x => _data.MapTapped += x, x => _data.MapTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23751,9 +21229,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PitchChanged += x, x => _data.PitchChanged -= x); + }, x => _data.PitchChanged += x, x => _data.PitchChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23761,9 +21237,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23771,9 +21245,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TransformOriginChanged += x, x => _data.TransformOriginChanged -= x); + }, x => _data.TransformOriginChanged += x, x => _data.TransformOriginChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23781,9 +21253,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ZoomLevelChanged += x, x => _data.ZoomLevelChanged -= x); + }, x => _data.ZoomLevelChanged += x, x => _data.ZoomLevelChanged -= x); } /// @@ -23808,9 +21278,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23835,9 +21303,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23862,9 +21328,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); + }, x => _data.MapContextRequested += x, x => _data.MapContextRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23872,9 +21336,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementClick += x, x => _data.MapElementClick -= x); + }, x => _data.MapElementClick += x, x => _data.MapElementClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23882,9 +21344,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); + }, x => _data.MapElementPointerEntered += x, x => _data.MapElementPointerEntered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -23892,9 +21352,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapElementsLayer sender, global::Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); + }, x => _data.MapElementPointerExited += x, x => _data.MapElementPointerExited -= x); } /// @@ -23919,9 +21377,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23946,9 +21402,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -23973,9 +21427,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24000,9 +21452,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24027,9 +21477,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24054,9 +21502,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24064,9 +21510,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.Controls.Maps.MapScene sender, global::Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); + }, x => _data.TargetCameraChanged += x, x => _data.TargetCameraChanged -= x); } /// @@ -24091,9 +21535,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24118,9 +21560,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24145,9 +21585,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24172,9 +21610,7 @@ namespace Windows.UI.Xaml.Controls.Maps { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -24345,9 +21781,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24372,9 +21806,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24399,9 +21831,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24426,9 +21856,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); } /// @@ -24453,9 +21881,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24480,9 +21906,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24490,9 +21914,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -24517,9 +21939,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.Controls.Primitives.ColorSpectrum sender, global::Windows.UI.Xaml.Controls.ColorChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ColorChanged += x, x => _data.ColorChanged -= x); + }, x => _data.ColorChanged += x, x => _data.ColorChanged -= x); } /// @@ -24544,9 +21964,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24571,9 +21989,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24598,9 +22014,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24625,9 +22039,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24635,9 +22047,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.Controls.Primitives.FlyoutBase sender, global::Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Closing += x, x => _data.Closing -= x); + }, x => _data.Closing += x, x => _data.Closing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24645,9 +22055,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24655,9 +22063,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24665,9 +22071,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Opening += x, x => _data.Opening -= x); + }, x => _data.Opening += x, x => _data.Opening -= x); } /// @@ -24692,9 +22096,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24719,9 +22121,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24729,9 +22129,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -24756,9 +22154,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24783,9 +22179,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24810,9 +22204,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24837,9 +22229,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -24864,9 +22254,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24874,9 +22262,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -24901,9 +22287,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24928,9 +22312,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -24955,9 +22337,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -24965,9 +22345,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -24992,9 +22370,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); + }, x => _data.HorizontalSnapPointsChanged += x, x => _data.HorizontalSnapPointsChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25002,9 +22378,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); + }, x => _data.VerticalSnapPointsChanged += x, x => _data.VerticalSnapPointsChanged -= x); } /// @@ -25029,9 +22403,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Closed += x, x => _data.Closed -= x); + }, x => _data.Closed += x, x => _data.Closed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25039,9 +22411,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); } /// @@ -25066,9 +22436,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25093,9 +22461,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25120,9 +22486,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -25147,9 +22511,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.ScrollEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scroll += x, x => _data.Scroll -= x); + }, x => _data.Scroll += x, x => _data.Scroll -= x); } /// @@ -25174,9 +22536,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -25201,9 +22561,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25228,9 +22586,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25255,9 +22611,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragCompletedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25265,9 +22619,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragDeltaEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragDelta += x, x => _data.DragDelta -= x); + }, x => _data.DragDelta += x, x => _data.DragDelta -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25275,9 +22627,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.Controls.Primitives.DragStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); } /// @@ -25302,9 +22652,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Checked += x, x => _data.Checked -= x); + }, x => _data.Checked += x, x => _data.Checked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25312,9 +22660,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Indeterminate += x, x => _data.Indeterminate -= x); + }, x => _data.Indeterminate += x, x => _data.Indeterminate -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25322,9 +22668,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unchecked += x, x => _data.Unchecked -= x); + }, x => _data.Unchecked += x, x => _data.Unchecked -= x); } /// @@ -25349,9 +22693,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25376,9 +22718,7 @@ namespace Windows.UI.Xaml.Controls.Primitives { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -25429,9 +22769,7 @@ namespace Windows.UI.Xaml.Data { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25456,9 +22794,7 @@ namespace Windows.UI.Xaml.Data { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25483,9 +22819,7 @@ namespace Windows.UI.Xaml.Data { void Handler(object sender, object instance) => eventHandler(instance); return Handler; - } - - , x => _data.ElementInstanceChanged += x, x => _data.ElementInstanceChanged -= x); + }, x => _data.ElementInstanceChanged += x, x => _data.ElementInstanceChanged -= x); } /// @@ -25510,9 +22844,7 @@ namespace Windows.UI.Xaml.Data { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); + }, x => _data.CurrentChanged += x, x => _data.CurrentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25520,9 +22852,7 @@ namespace Windows.UI.Xaml.Data { void Handler(object sender, global::Windows.UI.Xaml.Data.CurrentChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); + }, x => _data.CurrentChanging += x, x => _data.CurrentChanging -= x); } } @@ -25577,9 +22907,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25587,9 +22915,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.ContentLink sender, global::Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25597,9 +22923,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); } /// @@ -25624,9 +22948,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25651,9 +22973,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.Hyperlink sender, global::Windows.UI.Xaml.Documents.HyperlinkClickEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25661,9 +22981,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25671,9 +22989,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); } /// @@ -25698,9 +23014,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); + }, x => _data.AccessKeyDisplayDismissed += x, x => _data.AccessKeyDisplayDismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25708,9 +23022,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); + }, x => _data.AccessKeyDisplayRequested += x, x => _data.AccessKeyDisplayRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25718,9 +23030,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.Documents.TextElement sender, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); + }, x => _data.AccessKeyInvoked += x, x => _data.AccessKeyInvoked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25728,9 +23038,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25755,9 +23063,7 @@ namespace Windows.UI.Xaml.Documents { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -25808,9 +23114,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25835,9 +23139,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -25862,9 +23164,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25872,9 +23172,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.Input.KeyboardAccelerator sender, global::Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -25899,9 +23197,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25909,9 +23205,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.CanExecuteRequested += x, x => _data.CanExecuteRequested -= x); + }, x => _data.CanExecuteRequested += x, x => _data.CanExecuteRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25919,9 +23213,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -25929,9 +23221,7 @@ namespace Windows.UI.Xaml.Input { void Handler(global::Windows.UI.Xaml.Input.XamlUICommand sender, global::Windows.UI.Xaml.Input.ExecuteRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ExecuteRequested += x, x => _data.ExecuteRequested -= x); + }, x => _data.ExecuteRequested += x, x => _data.ExecuteRequested -= x); } } @@ -25970,9 +23260,7 @@ namespace Windows.UI.Xaml.Interop { void Handler(global::Windows.UI.Xaml.Interop.IBindableObservableVector vector, object e) => eventHandler((vector, e)); return Handler; - } - - , x => _data.VectorChanged += x, x => _data.VectorChanged -= x); + }, x => _data.VectorChanged += x, x => _data.VectorChanged -= x); } } @@ -26059,9 +23347,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26086,9 +23372,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26113,9 +23397,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26140,9 +23422,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26167,9 +23447,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26194,9 +23472,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26204,9 +23480,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); } /// @@ -26231,9 +23505,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26258,9 +23530,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.Media.LoadedImageSurface sender, global::Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); + }, x => _data.LoadCompleted += x, x => _data.LoadCompleted -= x); } /// @@ -26285,9 +23555,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26312,9 +23580,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26339,9 +23605,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26366,9 +23630,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26393,9 +23655,7 @@ namespace Windows.UI.Xaml.Media { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -26470,9 +23730,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26497,9 +23755,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.Media.Animation.ConnectedAnimation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -26524,9 +23780,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26551,9 +23805,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26578,9 +23830,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26605,9 +23855,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26632,9 +23880,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26659,9 +23905,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26686,9 +23930,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26696,9 +23938,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } /// @@ -26723,9 +23963,7 @@ namespace Windows.UI.Xaml.Media.Animation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -26768,9 +24006,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(object sender, global::Windows.UI.Xaml.Media.Imaging.DownloadProgressEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); + }, x => _data.DownloadProgress += x, x => _data.DownloadProgress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26778,9 +24014,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(object sender, global::Windows.UI.Xaml.ExceptionRoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageFailed += x, x => _data.ImageFailed -= x); + }, x => _data.ImageFailed += x, x => _data.ImageFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26788,9 +24022,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(object sender, global::Windows.UI.Xaml.RoutedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ImageOpened += x, x => _data.ImageOpened -= x); + }, x => _data.ImageOpened += x, x => _data.ImageOpened -= x); } /// @@ -26815,9 +24047,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.Opened += x, x => _data.Opened -= x); + }, x => _data.Opened += x, x => _data.Opened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26825,9 +24055,7 @@ namespace Windows.UI.Xaml.Media.Imaging { void Handler(global::Windows.UI.Xaml.Media.Imaging.SvgImageSource sender, global::Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.OpenFailed += x, x => _data.OpenFailed -= x); + }, x => _data.OpenFailed += x, x => _data.OpenFailed -= x); } } @@ -26866,9 +24094,7 @@ namespace Windows.UI.Xaml.Media.Media3D { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -26907,9 +24133,7 @@ namespace Windows.UI.Xaml.Navigation { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); } } @@ -26948,9 +24172,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(object sender, global::Windows.UI.Xaml.Printing.AddPagesEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AddPages += x, x => _data.AddPages -= x); + }, x => _data.AddPages += x, x => _data.AddPages -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26958,9 +24180,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(global::Windows.UI.Xaml.DependencyObject sender, global::Windows.UI.Xaml.DataContextChangedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); + }, x => _data.DataContextChanged += x, x => _data.DataContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26968,9 +24188,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(object sender, global::Windows.UI.Xaml.Printing.GetPreviewPageEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GetPreviewPage += x, x => _data.GetPreviewPage -= x); + }, x => _data.GetPreviewPage += x, x => _data.GetPreviewPage -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -26978,9 +24196,7 @@ namespace Windows.UI.Xaml.Printing { void Handler(object sender, global::Windows.UI.Xaml.Printing.PaginateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Paginate += x, x => _data.Paginate -= x); + }, x => _data.Paginate += x, x => _data.Paginate -= x); } } @@ -27019,9 +24235,7 @@ namespace Windows.Web.Http.Filters { void Handler(global::Windows.Web.Http.Filters.HttpBaseProtocolFilter sender, global::Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); + }, x => _data.ServerCustomValidationRequested += x, x => _data.ServerCustomValidationRequested -= x); } } @@ -27060,9 +24274,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27070,9 +24282,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27080,9 +24290,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27090,9 +24298,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27100,9 +24306,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27110,9 +24314,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27120,9 +24322,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27130,9 +24330,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27140,9 +24338,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27150,9 +24346,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27160,9 +24354,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27170,9 +24362,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27180,9 +24370,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27190,9 +24378,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27200,9 +24386,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27210,9 +24394,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27220,9 +24402,7 @@ namespace Windows.Web.UI { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } } @@ -27265,9 +24445,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.AcceleratorKeyPressed += x, x => _data.AcceleratorKeyPressed -= x); + }, x => _data.AcceleratorKeyPressed += x, x => _data.AcceleratorKeyPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27275,9 +24453,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); + }, x => _data.ContainsFullScreenElementChanged += x, x => _data.ContainsFullScreenElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27285,9 +24461,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ContentLoading += x, x => _data.ContentLoading -= x); + }, x => _data.ContentLoading += x, x => _data.ContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27295,9 +24469,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); + }, x => _data.DOMContentLoaded += x, x => _data.DOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27305,9 +24477,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlContentLoadingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); + }, x => _data.FrameContentLoading += x, x => _data.FrameContentLoading -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27315,9 +24485,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); + }, x => _data.FrameDOMContentLoaded += x, x => _data.FrameDOMContentLoaded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27325,9 +24493,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); + }, x => _data.FrameNavigationCompleted += x, x => _data.FrameNavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27335,9 +24501,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); + }, x => _data.FrameNavigationStarting += x, x => _data.FrameNavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27345,9 +24509,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.GotFocus += x, x => _data.GotFocus -= x); + }, x => _data.GotFocus += x, x => _data.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27355,9 +24517,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); + }, x => _data.LongRunningScriptDetected += x, x => _data.LongRunningScriptDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27365,9 +24525,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.LostFocus += x, x => _data.LostFocus -= x); + }, x => _data.LostFocus += x, x => _data.LostFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27375,9 +24533,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControl sender, global::Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.MoveFocusRequested += x, x => _data.MoveFocusRequested -= x); + }, x => _data.MoveFocusRequested += x, x => _data.MoveFocusRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27385,9 +24541,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationCompletedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); + }, x => _data.NavigationCompleted += x, x => _data.NavigationCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27395,9 +24549,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNavigationStartingEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); + }, x => _data.NavigationStarting += x, x => _data.NavigationStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27405,9 +24557,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); + }, x => _data.NewWindowRequested += x, x => _data.NewWindowRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27415,9 +24565,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlPermissionRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); + }, x => _data.PermissionRequested += x, x => _data.PermissionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27425,9 +24573,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlScriptNotifyEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); + }, x => _data.ScriptNotify += x, x => _data.ScriptNotify -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27435,9 +24581,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); + }, x => _data.UnsafeContentWarningDisplaying += x, x => _data.UnsafeContentWarningDisplaying -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27445,9 +24589,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); + }, x => _data.UnsupportedUriSchemeIdentified += x, x => _data.UnsupportedUriSchemeIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27455,9 +24597,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); + }, x => _data.UnviewableContentIdentified += x, x => _data.UnviewableContentIdentified -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27465,9 +24605,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.IWebViewControl sender, global::Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); + }, x => _data.WebResourceRequested += x, x => _data.WebResourceRequested -= x); } /// @@ -27492,9 +24630,7 @@ namespace Windows.Web.UI.Interop { void Handler(global::Windows.Web.UI.Interop.WebViewControlProcess sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => _data.ProcessExited += x, x => _data.ProcessExited -= x); + }, x => _data.ProcessExited += x, x => _data.ProcessExited -= x); } } @@ -27512,9 +24648,7 @@ namespace Windows.ApplicationModel.Chat { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged += x, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged -= x); + }, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged += x, x => global::Windows.ApplicationModel.Chat.RcsManager.TransportListChanged -= x); } } @@ -27532,9 +24666,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated += x, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated += x, x => global::Windows.ApplicationModel.Core.CoreApplication.BackgroundActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27542,9 +24674,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.EnteredBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.EnteredBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27552,9 +24682,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Exiting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27562,9 +24690,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.LeavingBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground += x, x => global::Windows.ApplicationModel.Core.CoreApplication.LeavingBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27572,9 +24698,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Resuming -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27582,9 +24706,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.SuspendingEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending += x, x => global::Windows.ApplicationModel.Core.CoreApplication.Suspending -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27592,9 +24714,7 @@ namespace Windows.ApplicationModel.Core { void Handler(object sender, global::Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected += x, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected -= x); + }, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected += x, x => global::Windows.ApplicationModel.Core.CoreApplication.UnhandledErrorDetected -= x); } } @@ -27612,9 +24732,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.ContentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27622,9 +24740,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, global::Windows.ApplicationModel.DataTransfer.ClipboardHistoryChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27632,9 +24748,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.HistoryEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27642,9 +24756,7 @@ namespace Windows.ApplicationModel.DataTransfer { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged -= x); + }, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged += x, x => global::Windows.ApplicationModel.DataTransfer.Clipboard.RoamingEnabledChanged -= x); } } @@ -27662,9 +24774,7 @@ namespace Windows.Foundation.Diagnostics { void Handler(object sender, global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged += x, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged -= x); + }, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged += x, x => global::Windows.Foundation.Diagnostics.AsyncCausalityTracer.TracingStatusChanged -= x); } } @@ -27682,9 +24792,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded -= x); + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27692,9 +24800,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.ArcadeStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved -= x); + }, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved += x, x => global::Windows.Gaming.Input.ArcadeStick.ArcadeStickRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27702,9 +24808,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded -= x); + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27712,9 +24816,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.FlightStick e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved -= x); + }, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved += x, x => global::Windows.Gaming.Input.FlightStick.FlightStickRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27722,9 +24824,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.Gamepad.GamepadAdded += x, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded -= x); + }, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded += x, x => global::Windows.Gaming.Input.Gamepad.GamepadAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27732,9 +24832,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.Gamepad e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved += x, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved -= x); + }, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved += x, x => global::Windows.Gaming.Input.Gamepad.GamepadRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27742,9 +24840,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded -= x); + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27752,9 +24848,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RacingWheel e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved -= x); + }, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved += x, x => global::Windows.Gaming.Input.RacingWheel.RacingWheelRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27762,9 +24856,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded -= x); + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27772,9 +24864,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.RawGameController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved -= x); + }, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved += x, x => global::Windows.Gaming.Input.RawGameController.RawGameControllerRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27782,9 +24872,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded -= x); + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27792,9 +24880,7 @@ namespace Windows.Gaming.Input { void Handler(object sender, global::Windows.Gaming.Input.UINavigationController e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved -= x); + }, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved += x, x => global::Windows.Gaming.Input.UINavigationController.UINavigationControllerRemoved -= x); } } @@ -27812,9 +24898,7 @@ namespace Windows.Gaming.UI { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged += x, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged -= x); + }, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged += x, x => global::Windows.Gaming.UI.GameBar.IsInputRedirectedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27822,9 +24906,7 @@ namespace Windows.Gaming.UI { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Gaming.UI.GameBar.VisibilityChanged += x, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged -= x); + }, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged += x, x => global::Windows.Gaming.UI.GameBar.VisibilityChanged -= x); } } @@ -27842,9 +24924,7 @@ namespace Windows.Graphics.Display { void Handler(global::Windows.Graphics.Display.DisplayInformation sender, object args) => eventHandler((sender, args)); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated -= x); + }, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayInformation.DisplayContentsInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27852,9 +24932,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.ColorProfileChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27862,9 +24940,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated += x, x => global::Windows.Graphics.Display.DisplayProperties.DisplayContentsInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27872,9 +24948,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.LogicalDpiChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27882,9 +24956,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.OrientationChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27892,9 +24964,7 @@ namespace Windows.Graphics.Display { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged -= x); + }, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged += x, x => global::Windows.Graphics.Display.DisplayProperties.StereoEnabledChanged -= x); } } @@ -27912,9 +24982,7 @@ namespace Windows.Graphics.Holographic { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged += x, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged -= x); + }, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged += x, x => global::Windows.Graphics.Holographic.HolographicSpace.IsAvailableChanged -= x); } } @@ -27932,9 +25000,7 @@ namespace Windows.Media.Core.Preview { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged += x, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged -= x); + }, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged += x, x => global::Windows.Media.Core.Preview.SoundLevelBroker.SoundLevelChanged -= x); } } @@ -27952,9 +25018,7 @@ namespace Windows.Media.Devices { void Handler(object sender, global::Windows.Media.Devices.DefaultAudioCaptureDeviceChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged -= x); + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioCaptureDeviceChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27962,9 +25026,7 @@ namespace Windows.Media.Devices { void Handler(object sender, global::Windows.Media.Devices.DefaultAudioRenderDeviceChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged -= x); + }, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged += x, x => global::Windows.Media.Devices.MediaDevice.DefaultAudioRenderDeviceChanged -= x); } } @@ -27982,9 +25044,7 @@ namespace Windows.Media.Playback { void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground -= x); + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -27992,9 +25052,7 @@ namespace Windows.Media.Playback { void Handler(object sender, global::Windows.Media.Playback.MediaPlayerDataReceivedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground -= x); + }, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground += x, x => global::Windows.Media.Playback.BackgroundMediaPlayer.MessageReceivedFromForeground -= x); } } @@ -28012,9 +25070,7 @@ namespace Windows.Networking.Connectivity { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged += x, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged -= x); + }, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged += x, x => global::Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged -= x); } } @@ -28032,9 +25088,7 @@ namespace Windows.Networking.NetworkOperators { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged += x, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged -= x); + }, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged += x, x => global::Windows.Networking.NetworkOperators.ESimManager.ServiceInfoChanged -= x); } } @@ -28052,9 +25106,7 @@ namespace Windows.Networking.Proximity { void Handler(object sender, global::Windows.Networking.Proximity.ConnectionRequestedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested += x, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested -= x); + }, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested += x, x => global::Windows.Networking.Proximity.PeerFinder.ConnectionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28062,9 +25114,7 @@ namespace Windows.Networking.Proximity { void Handler(object sender, global::Windows.Networking.Proximity.TriggeredConnectionStateChangedEventArgs args) => eventHandler(args); return Handler; - } - - , x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged += x, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged -= x); + }, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged += x, x => global::Windows.Networking.Proximity.PeerFinder.TriggeredConnectionStateChanged -= x); } } @@ -28082,9 +25132,7 @@ namespace Windows.Perception.Spatial { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged += x, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged -= x); + }, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged += x, x => global::Windows.Perception.Spatial.SpatialStageFrameOfReference.CurrentChanged -= x); } } @@ -28102,9 +25150,7 @@ namespace Windows.Phone.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged += x, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged -= x); + }, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged += x, x => global::Windows.Phone.System.Power.PowerManager.PowerSavingModeChanged -= x); } } @@ -28122,9 +25168,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.BackPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.BackPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28132,9 +25176,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraHalfPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28142,9 +25184,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28152,9 +25192,7 @@ namespace Windows.Phone.UI.Input { void Handler(object sender, global::Windows.Phone.UI.Input.CameraEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased -= x); + }, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased += x, x => global::Windows.Phone.UI.Input.HardwareButtons.CameraReleased -= x); } } @@ -28172,9 +25210,7 @@ namespace Windows.Security.Authentication.Identity.Provider { void Handler(object sender, global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged += x, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged -= x); + }, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged += x, x => global::Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication.AuthenticationStageChanged -= x); } } @@ -28192,9 +25228,7 @@ namespace Windows.System { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased -= x); + }, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageDecreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28202,9 +25236,7 @@ namespace Windows.System { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased -= x); + }, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased += x, x => global::Windows.System.MemoryManager.AppMemoryUsageIncreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28212,9 +25244,7 @@ namespace Windows.System { void Handler(object sender, global::Windows.System.AppMemoryUsageLimitChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging += x, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging -= x); + }, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging += x, x => global::Windows.System.MemoryManager.AppMemoryUsageLimitChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28222,9 +25252,7 @@ namespace Windows.System { void Handler(object sender, global::Windows.System.UserDeviceAssociationChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged += x, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged -= x); + }, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged += x, x => global::Windows.System.UserDeviceAssociation.UserDeviceAssociationChanged -= x); } } @@ -28242,9 +25270,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased -= x); + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageIncreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28252,9 +25278,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + }, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.BackgroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28262,9 +25286,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased -= x); + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageIncreased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28272,9 +25294,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); + }, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow += x, x => global::Windows.System.Power.ForegroundEnergyManager.RecentEnergyUsageReturnedToLow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28282,9 +25302,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.BatteryStatusChanged += x, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged -= x); + }, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged += x, x => global::Windows.System.Power.PowerManager.BatteryStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28292,9 +25310,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged += x, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged -= x); + }, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged += x, x => global::Windows.System.Power.PowerManager.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28302,9 +25318,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged += x, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged -= x); + }, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged += x, x => global::Windows.System.Power.PowerManager.PowerSupplyStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28312,9 +25326,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged += x, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged -= x); + }, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged += x, x => global::Windows.System.Power.PowerManager.RemainingChargePercentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28322,9 +25334,7 @@ namespace Windows.System.Power { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged += x, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged -= x); + }, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged += x, x => global::Windows.System.Power.PowerManager.RemainingDischargeTimeChanged -= x); } } @@ -28342,9 +25352,7 @@ namespace Windows.System.Profile { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged += x, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged -= x); + }, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged += x, x => global::Windows.System.Profile.PlatformDiagnosticsAndUsageDataSettings.CollectionLevelChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28352,9 +25360,7 @@ namespace Windows.System.Profile { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged += x, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged -= x); + }, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged += x, x => global::Windows.System.Profile.SystemSetupInfo.OutOfBoxExperienceStateChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28362,9 +25368,7 @@ namespace Windows.System.Profile { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged += x, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged -= x); + }, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged += x, x => global::Windows.System.Profile.WindowsIntegrityPolicy.PolicyChanged -= x); } } @@ -28382,9 +25386,7 @@ namespace Windows.UI.ViewManagement { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged += x, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged -= x); + }, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged += x, x => global::Windows.UI.ViewManagement.ProjectionManager.ProjectionDisplayAvailableChanged -= x); } } @@ -28402,9 +25404,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.Activation.IActivatedEventArgs eventArgs) => eventHandler(eventArgs); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Activated += x, x => global::Windows.UI.WebUI.WebUIApplication.Activated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Activated += x, x => global::Windows.UI.WebUI.WebUIApplication.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28412,9 +25412,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs eventArgs) => eventHandler(eventArgs); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated += x, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated += x, x => global::Windows.UI.WebUI.WebUIApplication.BackgroundActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28422,9 +25420,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.IEnteredBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.EnteredBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28432,9 +25428,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.ILeavingBackgroundEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground += x, x => global::Windows.UI.WebUI.WebUIApplication.LeavingBackground -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28442,9 +25436,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.UI.WebUI.IWebUINavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Navigated += x, x => global::Windows.UI.WebUI.WebUIApplication.Navigated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Navigated += x, x => global::Windows.UI.WebUI.WebUIApplication.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28452,9 +25444,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.UI.WebUI.NewWebUIViewCreatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated += x, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated += x, x => global::Windows.UI.WebUI.WebUIApplication.NewWebUIViewCreated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28462,9 +25452,7 @@ namespace Windows.UI.WebUI { void Handler(object sender) => eventHandler(sender); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Resuming += x, x => global::Windows.UI.WebUI.WebUIApplication.Resuming -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Resuming += x, x => global::Windows.UI.WebUI.WebUIApplication.Resuming -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28472,9 +25460,7 @@ namespace Windows.UI.WebUI { void Handler(object sender, global::Windows.ApplicationModel.ISuspendingEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.WebUI.WebUIApplication.Suspending += x, x => global::Windows.UI.WebUI.WebUIApplication.Suspending -= x); + }, x => global::Windows.UI.WebUI.WebUIApplication.Suspending += x, x => global::Windows.UI.WebUI.WebUIApplication.Suspending -= x); } } @@ -28492,9 +25478,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, object args) => eventHandler(args); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged += x, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged -= x); + }, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged += x, x => global::Windows.UI.Xaml.Input.AccessKeyManager.IsDisplayModeEnabledChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28502,9 +25486,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.GettingFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GettingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28512,9 +25494,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerGotFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.GotFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28522,9 +25502,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.LosingFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LosingFocus -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28532,9 +25510,7 @@ namespace Windows.UI.Xaml.Input { void Handler(object sender, global::Windows.UI.Xaml.Input.FocusManagerLostFocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus -= x); + }, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus += x, x => global::Windows.UI.Xaml.Input.FocusManager.LostFocus -= x); } } @@ -28552,9 +25528,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, global::Windows.UI.Xaml.Media.RenderedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered -= x); + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28562,9 +25536,7 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering -= x); + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.Rendering -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -28572,8 +25544,6 @@ namespace Windows.UI.Xaml.Media { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost -= x); + }, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost += x, x => global::Windows.UI.Xaml.Media.CompositionTarget.SurfaceContentsLost -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.monoandroid81.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.monoandroid10.0.approved.txt similarity index 82% rename from src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.monoandroid81.approved.txt rename to src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.monoandroid10.0.approved.txt index 8f9e8e7..b37024d 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.monoandroid81.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.monoandroid10.0.approved.txt @@ -19,9 +19,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29,9 +27,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -39,9 +35,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); + }, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -49,9 +43,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); + }, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -59,9 +51,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -69,9 +59,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); + }, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -79,9 +67,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); + }, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -89,9 +75,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -99,9 +83,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -109,8 +91,6 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.monoandroid90.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.monoandroid90.approved.txt index 8f9e8e7..b37024d 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.monoandroid90.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.monoandroid90.approved.txt @@ -19,9 +19,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29,9 +27,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -39,9 +35,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); + }, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -49,9 +43,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); + }, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -59,9 +51,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -69,9 +59,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); + }, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -79,9 +67,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); + }, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -89,9 +75,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -99,9 +83,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -109,8 +91,6 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.netstandard2.0.approved.txt index 8f9e8e7..b37024d 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.netstandard2.0.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.netstandard2.0.approved.txt @@ -19,9 +19,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29,9 +27,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -39,9 +35,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); + }, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -49,9 +43,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); + }, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -59,9 +51,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -69,9 +59,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); + }, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -79,9 +67,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); + }, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -89,9 +75,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -99,9 +83,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -109,8 +91,6 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.uap10.0.17763.approved.txt index 8f9e8e7..b37024d 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.uap10.0.17763.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.uap10.0.17763.approved.txt @@ -19,9 +19,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29,9 +27,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -39,9 +35,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); + }, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -49,9 +43,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); + }, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -59,9 +51,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -69,9 +59,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); + }, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -79,9 +67,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); + }, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -89,9 +75,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -99,9 +83,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -109,8 +91,6 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.xamarinios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.xamarinios10.approved.txt index 8f9e8e7..b37024d 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.xamarinios10.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.xamarinios10.approved.txt @@ -19,9 +19,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29,9 +27,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -39,9 +35,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); + }, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -49,9 +43,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); + }, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -59,9 +51,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -69,9 +59,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); + }, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -79,9 +67,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); + }, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -89,9 +75,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -99,9 +83,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -109,8 +91,6 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.xamarinios1010.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.xamarinios1010.approved.txt deleted file mode 100644 index 2c23013..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.xamarinios1010.approved.txt +++ /dev/null @@ -1,110 +0,0 @@ - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.xamarinmac20.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.xamarinmac20.approved.txt index 8f9e8e7..b37024d 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.xamarinmac20.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.xamarinmac20.approved.txt @@ -19,9 +19,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29,9 +27,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -39,9 +35,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); + }, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -49,9 +43,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); + }, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -59,9 +51,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -69,9 +59,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); + }, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -79,9 +67,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); + }, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -89,9 +75,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -99,9 +83,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -109,8 +91,6 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.xamarinmac2020.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.xamarinmac2020.approved.txt deleted file mode 100644 index 2c23013..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.0.0.xamarinmac2020.approved.txt +++ /dev/null @@ -1,110 +0,0 @@ - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.monoandroid81.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.monoandroid81.approved.txt deleted file mode 100644 index 22b982e..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.monoandroid81.approved.txt +++ /dev/null @@ -1,126 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.monoandroid90.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.monoandroid90.approved.txt deleted file mode 100644 index 22b982e..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.monoandroid90.approved.txt +++ /dev/null @@ -1,126 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.netstandard2.0.approved.txt deleted file mode 100644 index 22b982e..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.netstandard2.0.approved.txt +++ /dev/null @@ -1,126 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.uap10.0.17763.approved.txt deleted file mode 100644 index 22b982e..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.uap10.0.17763.approved.txt +++ /dev/null @@ -1,126 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.xamarinios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.xamarinios10.approved.txt deleted file mode 100644 index 22b982e..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.xamarinios10.approved.txt +++ /dev/null @@ -1,126 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.xamarinios1010.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.xamarinios1010.approved.txt deleted file mode 100644 index 35d3388..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.xamarinios1010.approved.txt +++ /dev/null @@ -1,120 +0,0 @@ - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.xamarinmac20.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.xamarinmac20.approved.txt deleted file mode 100644 index 22b982e..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.xamarinmac20.approved.txt +++ /dev/null @@ -1,126 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.xamarinmac2020.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.xamarinmac2020.approved.txt deleted file mode 100644 index 35d3388..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.1.0.xamarinmac2020.approved.txt +++ /dev/null @@ -1,120 +0,0 @@ - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.monoandroid81.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.monoandroid81.approved.txt deleted file mode 100644 index d9f8a01..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.monoandroid81.approved.txt +++ /dev/null @@ -1,125 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.monoandroid90.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.monoandroid90.approved.txt deleted file mode 100644 index d9f8a01..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.monoandroid90.approved.txt +++ /dev/null @@ -1,125 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.netstandard2.0.approved.txt deleted file mode 100644 index d9f8a01..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.netstandard2.0.approved.txt +++ /dev/null @@ -1,125 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.uap10.0.17763.approved.txt deleted file mode 100644 index d9f8a01..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.uap10.0.17763.approved.txt +++ /dev/null @@ -1,125 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.xamarinios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.xamarinios10.approved.txt deleted file mode 100644 index d9f8a01..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.xamarinios10.approved.txt +++ /dev/null @@ -1,125 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.xamarinmac20.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.xamarinmac20.approved.txt deleted file mode 100644 index d9f8a01..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.0.xamarinmac20.approved.txt +++ /dev/null @@ -1,125 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.monoandroid81.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.monoandroid81.approved.txt deleted file mode 100644 index 22b982e..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.monoandroid81.approved.txt +++ /dev/null @@ -1,126 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.monoandroid90.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.monoandroid90.approved.txt deleted file mode 100644 index 22b982e..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.monoandroid90.approved.txt +++ /dev/null @@ -1,126 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.netstandard2.0.approved.txt deleted file mode 100644 index 22b982e..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.netstandard2.0.approved.txt +++ /dev/null @@ -1,126 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.uap10.0.17763.approved.txt deleted file mode 100644 index 22b982e..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.uap10.0.17763.approved.txt +++ /dev/null @@ -1,126 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.xamarinios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.xamarinios10.approved.txt deleted file mode 100644 index 22b982e..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.xamarinios10.approved.txt +++ /dev/null @@ -1,126 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.xamarinmac20.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.xamarinmac20.approved.txt deleted file mode 100644 index 22b982e..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.3.1.xamarinmac20.approved.txt +++ /dev/null @@ -1,126 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Essentials -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.AccelerometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable AccelerometerShakeDetected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BarometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BarometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryBatteryInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.BatteryInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable BatteryEnergySaverStatusChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable CompassReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.CompassChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable ConnectivityConnectivityChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.ConnectivityChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable DeviceDisplayMainDisplayInfoChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.DisplayInfoChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable GyroscopeReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.GyroscopeChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable MagnetometerReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.MagnetometerChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable OrientationSensorReadingChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Essentials.OrientationSensorChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.monoandroid81.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.monoandroid81.approved.txt index f9f1733..736ae18 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.monoandroid81.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.monoandroid81.approved.txt @@ -19,9 +19,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29,9 +27,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -39,9 +35,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -49,9 +43,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); + }, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -59,9 +51,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); + }, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -69,9 +59,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged += x, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged -= x); + }, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged += x, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -79,9 +67,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -89,9 +75,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); + }, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -99,9 +83,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); + }, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -109,9 +91,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -119,9 +99,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -129,9 +107,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -139,8 +115,6 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.ActivityStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Platform.ActivityStateChanged += x, x => global::Xamarin.Essentials.Platform.ActivityStateChanged -= x); + }, x => global::Xamarin.Essentials.Platform.ActivityStateChanged += x, x => global::Xamarin.Essentials.Platform.ActivityStateChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.monoandroid90.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.monoandroid90.approved.txt index f9f1733..736ae18 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.monoandroid90.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.monoandroid90.approved.txt @@ -19,9 +19,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29,9 +27,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -39,9 +35,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -49,9 +43,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); + }, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -59,9 +51,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); + }, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -69,9 +59,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged += x, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged -= x); + }, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged += x, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -79,9 +67,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -89,9 +75,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); + }, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -99,9 +83,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); + }, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -109,9 +91,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -119,9 +99,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -129,9 +107,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -139,8 +115,6 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.ActivityStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Platform.ActivityStateChanged += x, x => global::Xamarin.Essentials.Platform.ActivityStateChanged -= x); + }, x => global::Xamarin.Essentials.Platform.ActivityStateChanged += x, x => global::Xamarin.Essentials.Platform.ActivityStateChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.netstandard2.0.approved.txt index 828434b..acd5bd1 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.netstandard2.0.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.netstandard2.0.approved.txt @@ -19,9 +19,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29,9 +27,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -39,9 +35,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -49,9 +43,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); + }, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -59,9 +51,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); + }, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -69,9 +59,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged += x, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged -= x); + }, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged += x, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -79,9 +67,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -89,9 +75,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); + }, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -99,9 +83,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); + }, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -109,9 +91,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -119,9 +99,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -129,8 +107,6 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.uap10.0.17763.approved.txt index 828434b..acd5bd1 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.uap10.0.17763.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.uap10.0.17763.approved.txt @@ -19,9 +19,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29,9 +27,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -39,9 +35,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -49,9 +43,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); + }, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -59,9 +51,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); + }, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -69,9 +59,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged += x, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged -= x); + }, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged += x, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -79,9 +67,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -89,9 +75,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); + }, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -99,9 +83,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); + }, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -109,9 +91,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -119,9 +99,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -129,8 +107,6 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.xamarinios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.xamarinios10.approved.txt index 828434b..acd5bd1 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.xamarinios10.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.xamarinios10.approved.txt @@ -19,9 +19,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29,9 +27,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -39,9 +35,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -49,9 +43,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); + }, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -59,9 +51,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); + }, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -69,9 +59,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged += x, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged -= x); + }, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged += x, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -79,9 +67,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -89,9 +75,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); + }, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -99,9 +83,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); + }, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -109,9 +91,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -119,9 +99,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -129,8 +107,6 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.xamarinmac20.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.xamarinmac20.approved.txt index 828434b..acd5bd1 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.xamarinmac20.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Essentials.1.5.3.2.xamarinmac20.approved.txt @@ -19,9 +19,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.AccelerometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged += x, x => global::Xamarin.Essentials.Accelerometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -29,9 +27,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); + }, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected += x, x => global::Xamarin.Essentials.Accelerometer.ShakeDetected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -39,9 +35,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BarometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Barometer.ReadingChanged += x, x => global::Xamarin.Essentials.Barometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -49,9 +43,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.BatteryInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); + }, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged += x, x => global::Xamarin.Essentials.Battery.BatteryInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -59,9 +51,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.EnergySaverStatusChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); + }, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged += x, x => global::Xamarin.Essentials.Battery.EnergySaverStatusChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -69,9 +59,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged += x, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged -= x); + }, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged += x, x => global::Xamarin.Essentials.Clipboard.ClipboardContentChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -79,9 +67,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.CompassChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Compass.ReadingChanged += x, x => global::Xamarin.Essentials.Compass.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -89,9 +75,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.ConnectivityChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); + }, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged += x, x => global::Xamarin.Essentials.Connectivity.ConnectivityChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -99,9 +83,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.DisplayInfoChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); + }, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged += x, x => global::Xamarin.Essentials.DeviceDisplay.MainDisplayInfoChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -109,9 +91,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.GyroscopeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged += x, x => global::Xamarin.Essentials.Gyroscope.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -119,9 +99,7 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.MagnetometerChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged += x, x => global::Xamarin.Essentials.Magnetometer.ReadingChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -129,8 +107,6 @@ namespace Xamarin.Essentials { void Handler(object sender, global::Xamarin.Essentials.OrientationSensorChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); + }, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged += x, x => global::Xamarin.Essentials.OrientationSensor.ReadingChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.monoandroid81.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.monoandroid81.approved.txt deleted file mode 100644 index ae60303..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.monoandroid81.approved.txt +++ /dev/null @@ -1,3827 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Android.Support.V4.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DrawerLayoutEvents Events(this global::Android.Support.V4.Widget.DrawerLayout item) => new DrawerLayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NestedScrollViewEvents Events(this global::Android.Support.V4.Widget.NestedScrollView item) => new NestedScrollViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DrawerLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.DrawerLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DrawerLayoutEvents(global::Android.Support.V4.Widget.DrawerLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerSlide => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NestedScrollViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.NestedScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NestedScrollViewEvents(global::Android.Support.V4.Widget.NestedScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - } -} - -namespace Android.Support.V7.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RecyclerViewEvents Events(this global::Android.Support.V7.Widget.RecyclerView item) => new RecyclerViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RecyclerViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V7.Widget.RecyclerView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RecyclerViewEvents(global::Android.Support.V7.Widget.RecyclerView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAttachedToWindow += x, x => _data.ChildViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewDetachedFromWindow += x, x => _data.ChildViewDetachedFromWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InterceptTouchEvent += x, x => _data.InterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RecyclerEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RecyclerEvent += x, x => _data.RecyclerEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RequestDisallowInterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RequestDisallowInterceptTouchEvent += x, x => _data.RequestDisallowInterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); - } -} - -namespace Android.Views -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewEvents Events(this global::Android.Views.View item) => new ViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewGroupEvents Events(this global::Android.Views.ViewGroup item) => new ViewGroupEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewEvents - { - private readonly global::Android.Views.View _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewEvents(global::Android.Views.View data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CapturedPointer => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CapturedPointerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ContextClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextMenuCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CreateContextMenuEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.DragEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.FocusChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GenericMotion => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.GenericMotionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Hover => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.HoverEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.KeyEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LayoutChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LongClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LongClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SystemUiVisibilityChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.SystemUiVisibilityChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Touch => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.TouchEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewGroupEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Views.ViewGroup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewGroupEvents(global::Android.Views.ViewGroup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationEnd => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationEndEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationRepeat => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStart => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationStartEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewAddedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); - } -} - -namespace Android.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TextViewEvents Events(this global::Android.Widget.TextView item) => new TextViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TextViewEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Widget.TextView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TextViewEvents(global::Android.Widget.TextView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AfterTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.AfterTextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BeforeTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EditorAction => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.TextView.EditorActionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Android -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsAppCompatActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity item) => new FormsAppCompatActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsApplicationActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsApplicationActivity item) => new FormsApplicationActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IBorderVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer item) => new IBorderVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDeviceInfoProviderEvents Events(this global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider item) => new IDeviceInfoProviderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ImageButtonRenderer item) => new ImageButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellItemRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IShellItemRenderer item) => new IShellItemRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellObservableFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.IShellObservableFragment item) => new IShellObservableFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.IShellSearchView item) => new IShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ItemsViewRenderer item) => new ItemsViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.Android.MasterDetailRenderer item) => new MasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellContentFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.ShellContentFragment item) => new ShellContentFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellItemRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.ShellItemRendererBase item) => new ShellItemRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSearchView item) => new ShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSectionRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSectionRenderer item) => new ShellSectionRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsAppCompatActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsAppCompatActivityEvents(global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsApplicationActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsApplicationActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsApplicationActivityEvents(global::Xamarin.Forms.Platform.Android.FormsApplicationActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IBorderVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IBorderVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDeviceInfoProviderEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDeviceInfoProviderEvents(global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ImageButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonRendererEvents(global::Xamarin.Forms.Platform.Android.ImageButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellItemRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellItemRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellItemRendererEvents(global::Xamarin.Forms.Platform.Android.IShellItemRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellObservableFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellObservableFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellObservableFragmentEvents(global::Xamarin.Forms.Platform.Android.IShellObservableFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.IShellSearchView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewRendererEvents : global::Android.Support.V7.Widget.RecyclerViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ItemsViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewRendererEvents(global::Xamarin.Forms.Platform.Android.ItemsViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailRendererEvents : global::Android.Support.V4.Widget.DrawerLayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Android.MasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailRendererEvents(global::Xamarin.Forms.Platform.Android.MasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::Android.Support.V4.Widget.NestedScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.Android.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellContentFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellContentFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellContentFragmentEvents(global::Xamarin.Forms.Platform.Android.ShellContentFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellItemRendererBaseEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellItemRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellItemRendererBaseEvents(global::Xamarin.Forms.Platform.Android.ShellItemRendererBase data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.ShellSearchView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSectionRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSectionRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSectionRendererEvents(global::Xamarin.Forms.Platform.Android.ShellSectionRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } -} - -namespace Xamarin.Forms.Platform.Android.FastRenderers -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer item) => new ButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FrameRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer item) => new FrameRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer item) => new ImageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LabelRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer item) => new LabelRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FrameRendererEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FrameRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LabelRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LabelRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.monoandroid90.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.monoandroid90.approved.txt deleted file mode 100644 index 9d28798..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.monoandroid90.approved.txt +++ /dev/null @@ -1,3837 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Android.Support.V4.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DrawerLayoutEvents Events(this global::Android.Support.V4.Widget.DrawerLayout item) => new DrawerLayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NestedScrollViewEvents Events(this global::Android.Support.V4.Widget.NestedScrollView item) => new NestedScrollViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DrawerLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.DrawerLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DrawerLayoutEvents(global::Android.Support.V4.Widget.DrawerLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerSlide => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NestedScrollViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.NestedScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NestedScrollViewEvents(global::Android.Support.V4.Widget.NestedScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - } -} - -namespace Android.Support.V7.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RecyclerViewEvents Events(this global::Android.Support.V7.Widget.RecyclerView item) => new RecyclerViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RecyclerViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V7.Widget.RecyclerView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RecyclerViewEvents(global::Android.Support.V7.Widget.RecyclerView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAttachedToWindow += x, x => _data.ChildViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewDetachedFromWindow += x, x => _data.ChildViewDetachedFromWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InterceptTouchEvent += x, x => _data.InterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RecyclerEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RecyclerEvent += x, x => _data.RecyclerEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RequestDisallowInterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RequestDisallowInterceptTouchEvent += x, x => _data.RequestDisallowInterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); - } -} - -namespace Android.Views -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewEvents Events(this global::Android.Views.View item) => new ViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewGroupEvents Events(this global::Android.Views.ViewGroup item) => new ViewGroupEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewEvents - { - private readonly global::Android.Views.View _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewEvents(global::Android.Views.View data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CapturedPointer => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CapturedPointerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ContextClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextMenuCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CreateContextMenuEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.DragEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.FocusChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GenericMotion => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.GenericMotionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Hover => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.HoverEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.KeyEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LayoutChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LongClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LongClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SystemUiVisibilityChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.SystemUiVisibilityChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Touch => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.TouchEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable UnhandledKeyEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.UnhandledKeyEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.UnhandledKeyEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.UnhandledKeyEvent += x, x => _data.UnhandledKeyEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewGroupEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Views.ViewGroup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewGroupEvents(global::Android.Views.ViewGroup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationEnd => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationEndEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationRepeat => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStart => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationStartEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewAddedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); - } -} - -namespace Android.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TextViewEvents Events(this global::Android.Widget.TextView item) => new TextViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TextViewEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Widget.TextView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TextViewEvents(global::Android.Widget.TextView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AfterTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.AfterTextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BeforeTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EditorAction => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.TextView.EditorActionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Android -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsAppCompatActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity item) => new FormsAppCompatActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsApplicationActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsApplicationActivity item) => new FormsApplicationActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IBorderVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer item) => new IBorderVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDeviceInfoProviderEvents Events(this global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider item) => new IDeviceInfoProviderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ImageButtonRenderer item) => new ImageButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellItemRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IShellItemRenderer item) => new IShellItemRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellObservableFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.IShellObservableFragment item) => new IShellObservableFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.IShellSearchView item) => new IShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ItemsViewRenderer item) => new ItemsViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.Android.MasterDetailRenderer item) => new MasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellContentFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.ShellContentFragment item) => new ShellContentFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellItemRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.ShellItemRendererBase item) => new ShellItemRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSearchView item) => new ShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSectionRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSectionRenderer item) => new ShellSectionRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsAppCompatActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsAppCompatActivityEvents(global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsApplicationActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsApplicationActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsApplicationActivityEvents(global::Xamarin.Forms.Platform.Android.FormsApplicationActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IBorderVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IBorderVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDeviceInfoProviderEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDeviceInfoProviderEvents(global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ImageButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonRendererEvents(global::Xamarin.Forms.Platform.Android.ImageButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellItemRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellItemRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellItemRendererEvents(global::Xamarin.Forms.Platform.Android.IShellItemRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellObservableFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellObservableFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellObservableFragmentEvents(global::Xamarin.Forms.Platform.Android.IShellObservableFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.IShellSearchView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewRendererEvents : global::Android.Support.V7.Widget.RecyclerViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ItemsViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewRendererEvents(global::Xamarin.Forms.Platform.Android.ItemsViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailRendererEvents : global::Android.Support.V4.Widget.DrawerLayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Android.MasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailRendererEvents(global::Xamarin.Forms.Platform.Android.MasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::Android.Support.V4.Widget.NestedScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.Android.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellContentFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellContentFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellContentFragmentEvents(global::Xamarin.Forms.Platform.Android.ShellContentFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellItemRendererBaseEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellItemRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellItemRendererBaseEvents(global::Xamarin.Forms.Platform.Android.ShellItemRendererBase data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.ShellSearchView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSectionRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSectionRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSectionRendererEvents(global::Xamarin.Forms.Platform.Android.ShellSectionRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } -} - -namespace Xamarin.Forms.Platform.Android.FastRenderers -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer item) => new ButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FrameRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer item) => new FrameRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer item) => new ImageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LabelRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer item) => new LabelRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FrameRendererEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FrameRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LabelRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LabelRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.netstandard2.0.approved.txt deleted file mode 100644 index 2f17a58..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.netstandard2.0.approved.txt +++ /dev/null @@ -1,2540 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.tizen40.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.tizen40.approved.txt deleted file mode 100644 index 1eba0bf..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.tizen40.approved.txt +++ /dev/null @@ -1,3390 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace ElmSharp -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::ElmSharp.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EvasObjectEvents Events(this global::ElmSharp.EvasObject item) => new EvasObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::ElmSharp.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PopupEvents Events(this global::ElmSharp.Popup item) => new PopupEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WidgetEvents Events(this global::ElmSharp.Widget item) => new WidgetEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::ElmSharp.LayoutEvents - { - private readonly global::ElmSharp.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::ElmSharp.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChangedByUser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChangedByUser += x, x => _data.ChangedByUser -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CursorChanged += x, x => _data.CursorChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EvasObjectEvents - { - private readonly global::ElmSharp.EvasObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EvasObjectEvents(global::ElmSharp.EvasObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Deleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Deleted += x, x => _data.Deleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.EvasKeyEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.EvasKeyEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MoreButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MoreButtonPressed += x, x => _data.MoreButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Moved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Moved += x, x => _data.Moved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RenderPost => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RenderPost += x, x => _data.RenderPost -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Resized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Resized += x, x => _data.Resized -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::ElmSharp.WidgetEvents - { - private readonly global::ElmSharp.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::ElmSharp.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ThemeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ThemeChanged += x, x => _data.ThemeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PopupEvents : global::ElmSharp.LayoutEvents - { - private readonly global::ElmSharp.Popup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PopupEvents(global::ElmSharp.Popup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Dismissed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OutsideClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OutsideClicked += x, x => _data.OutsideClicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ShowAnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ShowAnimationFinished += x, x => _data.ShowAnimationFinished -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TimedOut => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TimedOut += x, x => _data.TimedOut -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WidgetEvents : global::ElmSharp.EvasObjectEvents - { - private readonly global::ElmSharp.Widget _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WidgetEvents(global::ElmSharp.Widget data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DefaultPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.DefaultPlatform item) => new DefaultPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static GestureHandlerEvents Events(this global::Xamarin.Forms.Platform.Tizen.GestureHandler item) => new GestureHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITizenPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.ITizenPlatform item) => new ITizenPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LightweightPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.LightweightPlatform item) => new LightweightPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationDrawerEvents Events(this global::Xamarin.Forms.Platform.Tizen.NavigationDrawer item) => new NavigationDrawerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationViewEvents Events(this global::Xamarin.Forms.Platform.Tizen.NavigationView item) => new NavigationViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DefaultPlatformEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.DefaultPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DefaultPlatformEvents(global::Xamarin.Forms.Platform.Tizen.DefaultPlatform data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class GestureHandlerEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.GestureHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public GestureHandlerEvents(global::Xamarin.Forms.Platform.Tizen.GestureHandler data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITizenPlatformEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.ITizenPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITizenPlatformEvents(global::Xamarin.Forms.Platform.Tizen.ITizenPlatform data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LightweightPlatformEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.LightweightPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LightweightPlatformEvents(global::Xamarin.Forms.Platform.Tizen.LightweightPlatform data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationDrawerEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.NavigationDrawer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationDrawerEvents(global::Xamarin.Forms.Platform.Tizen.NavigationDrawer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationViewEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.NavigationView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationViewEvents(global::Xamarin.Forms.Platform.Tizen.NavigationView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MenuItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.GenListItemEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MenuItemSelected += x, x => _data.MenuItemSelected -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen.Native -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BoxEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Box item) => new BoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DateTimePickerDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog item) => new DateTimePickerDialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Dialog item) => new DialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditfieldEntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry item) => new EditfieldEntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDateTimeDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog item) => new IDateTimeDialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Page item) => new PageEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BoxEvents : global::ElmSharp.WidgetEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Box _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BoxEvents(global::Xamarin.Forms.Platform.Tizen.Native.Box data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DateTimePickerDialogEvents : global::Xamarin.Forms.Platform.Tizen.Native.DialogEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DateTimePickerDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DialogEvents : global::ElmSharp.PopupEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Dialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.Dialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Shown += x, x => _data.Shown -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditfieldEntryEvents : global::Xamarin.Forms.Platform.Tizen.Native.EntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditfieldEntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextBlockFocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextBlockFocused += x, x => _data.TextBlockFocused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextBlockUnfocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextBlockUnfocused += x, x => _data.TextBlockUnfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::ElmSharp.EntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDateTimeDialogEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDateTimeDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.IsPresentedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.IsPresentedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable UpdateIsPresentChangeable => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.UpdateIsPresentChangeableEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.UpdateIsPresentChangeableEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.UpdateIsPresentChangeable += x, x => _data.UpdateIsPresentChangeable -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::ElmSharp.LayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Platform.Tizen.Native.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen.Native.Watch -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WatchDataTimePickerDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog item) => new WatchDataTimePickerDialogEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WatchDataTimePickerDialogEvents : global::ElmSharp.PopupEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WatchDataTimePickerDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Platform.Tizen.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Platform.Tizen.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.uap10.0.17763.approved.txt deleted file mode 100644 index 18fdc19..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.uap10.0.17763.approved.txt +++ /dev/null @@ -1,2890 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.UWP -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellRendererCompletedEvents Events(this global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted item) => new EntryCellRendererCompletedEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsFlyoutEvents Events(this global::Xamarin.Forms.Platform.UWP.FormsFlyout item) => new FormsFlyoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer item) => new MasterDetailPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer item) => new NavigationPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperControlEvents Events(this global::Xamarin.Forms.Platform.UWP.StepperControl item) => new StepperControlEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer item) => new TabbedPageRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellRendererCompletedEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellRendererCompletedEvents(global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsFlyoutEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.FormsFlyout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsFlyoutEvents(global::Xamarin.Forms.Platform.UWP.FormsFlyout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OptionSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OptionSelected += x, x => _data.OptionSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageRendererEvents(global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageRendererEvents(global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperControlEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.StepperControl _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperControlEvents(global::Xamarin.Forms.Platform.UWP.StepperControl data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedPageRendererEvents(global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.WinRT -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperControlEvents Events(this global::Xamarin.Forms.Platform.WinRT.StepperControl item) => new StepperControlEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperControlEvents - { - private readonly global::Xamarin.Forms.Platform.WinRT.StepperControl _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperControlEvents(global::Xamarin.Forms.Platform.WinRT.StepperControl data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.xamarinios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.xamarinios10.approved.txt deleted file mode 100644 index 79a757c..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.xamarinios10.approved.txt +++ /dev/null @@ -1,3554 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace UIKit -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UIScrollViewEvents Events(this global::UIKit.UIScrollView item) => new UIScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UISplitViewControllerEvents Events(this global::UIKit.UISplitViewController item) => new UISplitViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UITabBarControllerEvents Events(this global::UIKit.UITabBarController item) => new UITabBarControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UIWebViewEvents Events(this global::UIKit.UIWebView item) => new UIWebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UIScrollViewEvents - { - private readonly global::UIKit.UIScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UIScrollViewEvents(global::UIKit.UIScrollView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DecelerationEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DecelerationEnded += x, x => _data.DecelerationEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DecelerationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DecelerationStarted += x, x => _data.DecelerationStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidChangeAdjustedContentInset => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidChangeAdjustedContentInset += x, x => _data.DidChangeAdjustedContentInset -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidZoom => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidZoom += x, x => _data.DidZoom -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DraggingEnded => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.DraggingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.DraggingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DraggingEnded += x, x => _data.DraggingEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DraggingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DraggingStarted += x, x => _data.DraggingStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollAnimationEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollAnimationEnded += x, x => _data.ScrollAnimationEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrolledToTop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrolledToTop += x, x => _data.ScrolledToTop -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillEndDragging => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.WillEndDraggingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.WillEndDraggingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillEndDragging += x, x => _data.WillEndDragging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ZoomingEnded => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.ZoomingEndedEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.ZoomingEndedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ZoomingEnded += x, x => _data.ZoomingEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ZoomingStarted => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIScrollViewZoomingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UIScrollViewZoomingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ZoomingStarted += x, x => _data.ZoomingStarted -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UISplitViewControllerEvents - { - private readonly global::UIKit.UISplitViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UISplitViewControllerEvents(global::UIKit.UISplitViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillChangeDisplayMode => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewControllerDisplayModeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewControllerDisplayModeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillChangeDisplayMode += x, x => _data.WillChangeDisplayMode -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillHideViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewHideEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewHideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillHideViewController += x, x => _data.WillHideViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillPresentViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewPresentEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewPresentEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillPresentViewController += x, x => _data.WillPresentViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillShowViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewShowEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewShowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillShowViewController += x, x => _data.WillShowViewController -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UITabBarControllerEvents - { - private readonly global::UIKit.UITabBarController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UITabBarControllerEvents(global::UIKit.UITabBarController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FinishedCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FinishedCustomizingViewControllers += x, x => _data.FinishedCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnCustomizingViewControllers += x, x => _data.OnCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnEndCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnEndCustomizingViewControllers += x, x => _data.OnEndCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewControllerSelected => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarSelectionEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarSelectionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewControllerSelected += x, x => _data.ViewControllerSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UIWebViewEvents - { - private readonly global::UIKit.UIWebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UIWebViewEvents(global::UIKit.UIWebView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadError => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIWebErrorArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UIWebErrorArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadError += x, x => _data.LoadError -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadFinished += x, x => _data.LoadFinished -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadStarted += x, x => _data.LoadStarted -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.iOS -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellFlyoutContentRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer item) => new IShellFlyoutContentRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchResultsRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer item) => new IShellSearchResultsRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.NavigationRenderer item) => new NavigationRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.PageRenderer item) => new PageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PhoneMasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer item) => new PhoneMasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellFlyoutContentRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer item) => new ShellFlyoutContentRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellRenderer item) => new ShellRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchResultsRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer item) => new ShellSearchResultsRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellTableViewSourceEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellTableViewSource item) => new ShellTableViewSourceEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.TabbedRenderer item) => new TabbedRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabletMasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer item) => new TabletMasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TemplatedCellEvents Events(this global::Xamarin.Forms.Platform.iOS.TemplatedCell item) => new TemplatedCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementTrackerEvents Events(this global::Xamarin.Forms.Platform.iOS.VisualElementTracker item) => new VisualElementTrackerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.WebViewRenderer item) => new WebViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WkWebViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer item) => new WkWebViewRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ElementChanged => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Platform.iOS.ElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.ElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellFlyoutContentRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellFlyoutContentRendererEvents(global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillAppear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillAppear += x, x => _data.WillAppear -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillDisappear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchResultsRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchResultsRendererEvents(global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => - { - void Handler(object sender, object e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.NavigationRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationRendererEvents(global::Xamarin.Forms.Platform.iOS.NavigationRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.PageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageRendererEvents(global::Xamarin.Forms.Platform.iOS.PageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PhoneMasterDetailRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PhoneMasterDetailRendererEvents(global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::UIKit.UIScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellFlyoutContentRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellFlyoutContentRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillAppear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillAppear += x, x => _data.WillAppear -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillDisappear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchResultsRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchResultsRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => - { - void Handler(object sender, object e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellTableViewSourceEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellTableViewSource _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellTableViewSourceEvents(global::Xamarin.Forms.Platform.iOS.ShellTableViewSource data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrolledEvent => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIScrollView>(eventHandler => - { - void Handler(object sender, global::UIKit.UIScrollView e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrolledEvent += x, x => _data.ScrolledEvent -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedRendererEvents : global::UIKit.UITabBarControllerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TabbedRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedRendererEvents(global::Xamarin.Forms.Platform.iOS.TabbedRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabletMasterDetailRendererEvents : global::UIKit.UISplitViewControllerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabletMasterDetailRendererEvents(global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TemplatedCellEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TemplatedCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TemplatedCellEvents(global::Xamarin.Forms.Platform.iOS.TemplatedCell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContentSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContentSizeChanged += x, x => _data.ContentSizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementTrackerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.VisualElementTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementTrackerEvents(global::Xamarin.Forms.Platform.iOS.VisualElementTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NativeControlUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewRendererEvents : global::UIKit.UIWebViewEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.WebViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewRendererEvents(global::Xamarin.Forms.Platform.iOS.WebViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WkWebViewRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WkWebViewRendererEvents(global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.xamarinios1010.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.xamarinios1010.approved.txt deleted file mode 100644 index 27bf853..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.xamarinios1010.approved.txt +++ /dev/null @@ -1,2534 +0,0 @@ - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.xamarinmac20.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.xamarinmac20.approved.txt deleted file mode 100644 index f5ffe67..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.xamarinmac20.approved.txt +++ /dev/null @@ -1,2940 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace AppKit -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NSPageControllerEvents Events(this global::AppKit.NSPageController item) => new NSPageControllerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NSPageControllerEvents - { - private readonly global::AppKit.NSPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NSPageControllerEvents(global::AppKit.NSPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidEndLiveTransition => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidEndLiveTransition += x, x => _data.DidEndLiveTransition -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidTransition => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPageControllerTransitionEventArgs>(eventHandler => - { - void Handler(object sender, global::AppKit.NSPageControllerTransitionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidTransition += x, x => _data.DidTransition -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PrepareViewController => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPageControllerPrepareViewControllerEventArgs>(eventHandler => - { - void Handler(object sender, global::AppKit.NSPageControllerPrepareViewControllerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PrepareViewController += x, x => _data.PrepareViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillStartLiveTransition => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillStartLiveTransition += x, x => _data.WillStartLiveTransition -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.MacOS -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer item) => new MasterDetailPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer item) => new NavigationPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.PageRenderer item) => new PageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer item) => new TabbedPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementTrackerEvents Events(this global::Xamarin.Forms.Platform.MacOS.VisualElementTracker item) => new VisualElementTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents : global::AppKit.NSPageControllerEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.PageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageRendererEvents(global::Xamarin.Forms.Platform.MacOS.PageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementTrackerEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.VisualElementTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementTrackerEvents(global::Xamarin.Forms.Platform.MacOS.VisualElementTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NativeControlUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.xamarinmac2020.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.xamarinmac2020.approved.txt deleted file mode 100644 index 27bf853..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.482894.xamarinmac2020.approved.txt +++ /dev/null @@ -1,2534 +0,0 @@ - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.monoandroid81.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.monoandroid81.approved.txt deleted file mode 100644 index 6664933..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.monoandroid81.approved.txt +++ /dev/null @@ -1,3827 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Android.Support.V4.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DrawerLayoutEvents Events(this global::Android.Support.V4.Widget.DrawerLayout item) => new DrawerLayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NestedScrollViewEvents Events(this global::Android.Support.V4.Widget.NestedScrollView item) => new NestedScrollViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DrawerLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.DrawerLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DrawerLayoutEvents(global::Android.Support.V4.Widget.DrawerLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerSlide => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NestedScrollViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.NestedScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NestedScrollViewEvents(global::Android.Support.V4.Widget.NestedScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - } -} - -namespace Android.Support.V7.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RecyclerViewEvents Events(this global::Android.Support.V7.Widget.RecyclerView item) => new RecyclerViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RecyclerViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V7.Widget.RecyclerView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RecyclerViewEvents(global::Android.Support.V7.Widget.RecyclerView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAttachedToWindow += x, x => _data.ChildViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewDetachedFromWindow += x, x => _data.ChildViewDetachedFromWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InterceptTouchEvent += x, x => _data.InterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RecyclerEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RecyclerEvent += x, x => _data.RecyclerEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RequestDisallowInterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RequestDisallowInterceptTouchEvent += x, x => _data.RequestDisallowInterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); - } -} - -namespace Android.Views -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewEvents Events(this global::Android.Views.View item) => new ViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewGroupEvents Events(this global::Android.Views.ViewGroup item) => new ViewGroupEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewEvents - { - private readonly global::Android.Views.View _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewEvents(global::Android.Views.View data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CapturedPointer => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CapturedPointerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ContextClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextMenuCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CreateContextMenuEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.DragEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.FocusChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GenericMotion => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.GenericMotionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Hover => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.HoverEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.KeyEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LayoutChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LongClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LongClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SystemUiVisibilityChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.SystemUiVisibilityChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Touch => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.TouchEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewGroupEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Views.ViewGroup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewGroupEvents(global::Android.Views.ViewGroup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationEnd => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationEndEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationRepeat => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStart => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationStartEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewAddedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); - } -} - -namespace Android.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TextViewEvents Events(this global::Android.Widget.TextView item) => new TextViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TextViewEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Widget.TextView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TextViewEvents(global::Android.Widget.TextView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AfterTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.AfterTextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BeforeTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EditorAction => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.TextView.EditorActionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Android -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsAppCompatActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity item) => new FormsAppCompatActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsApplicationActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsApplicationActivity item) => new FormsApplicationActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IBorderVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer item) => new IBorderVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDeviceInfoProviderEvents Events(this global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider item) => new IDeviceInfoProviderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ImageButtonRenderer item) => new ImageButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellItemRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IShellItemRenderer item) => new IShellItemRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellObservableFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.IShellObservableFragment item) => new IShellObservableFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.IShellSearchView item) => new IShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ItemsViewRenderer item) => new ItemsViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.Android.MasterDetailRenderer item) => new MasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellContentFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.ShellContentFragment item) => new ShellContentFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellItemRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.ShellItemRendererBase item) => new ShellItemRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSearchView item) => new ShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSectionRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSectionRenderer item) => new ShellSectionRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsAppCompatActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsAppCompatActivityEvents(global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsApplicationActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsApplicationActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsApplicationActivityEvents(global::Xamarin.Forms.Platform.Android.FormsApplicationActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IBorderVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IBorderVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDeviceInfoProviderEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDeviceInfoProviderEvents(global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ImageButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonRendererEvents(global::Xamarin.Forms.Platform.Android.ImageButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellItemRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellItemRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellItemRendererEvents(global::Xamarin.Forms.Platform.Android.IShellItemRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellObservableFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellObservableFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellObservableFragmentEvents(global::Xamarin.Forms.Platform.Android.IShellObservableFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.IShellSearchView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewRendererEvents : global::Android.Support.V7.Widget.RecyclerViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ItemsViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewRendererEvents(global::Xamarin.Forms.Platform.Android.ItemsViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailRendererEvents : global::Android.Support.V4.Widget.DrawerLayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Android.MasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailRendererEvents(global::Xamarin.Forms.Platform.Android.MasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::Android.Support.V4.Widget.NestedScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.Android.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellContentFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellContentFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellContentFragmentEvents(global::Xamarin.Forms.Platform.Android.ShellContentFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellItemRendererBaseEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellItemRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellItemRendererBaseEvents(global::Xamarin.Forms.Platform.Android.ShellItemRendererBase data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.ShellSearchView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSectionRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSectionRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSectionRendererEvents(global::Xamarin.Forms.Platform.Android.ShellSectionRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } -} - -namespace Xamarin.Forms.Platform.Android.FastRenderers -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer item) => new ButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FrameRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer item) => new FrameRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer item) => new ImageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LabelRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer item) => new LabelRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FrameRendererEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FrameRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LabelRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LabelRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.monoandroid90.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.monoandroid90.approved.txt deleted file mode 100644 index 54565b1..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.monoandroid90.approved.txt +++ /dev/null @@ -1,3837 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Android.Support.V4.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DrawerLayoutEvents Events(this global::Android.Support.V4.Widget.DrawerLayout item) => new DrawerLayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NestedScrollViewEvents Events(this global::Android.Support.V4.Widget.NestedScrollView item) => new NestedScrollViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DrawerLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.DrawerLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DrawerLayoutEvents(global::Android.Support.V4.Widget.DrawerLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerSlide => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NestedScrollViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.NestedScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NestedScrollViewEvents(global::Android.Support.V4.Widget.NestedScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - } -} - -namespace Android.Support.V7.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RecyclerViewEvents Events(this global::Android.Support.V7.Widget.RecyclerView item) => new RecyclerViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RecyclerViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V7.Widget.RecyclerView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RecyclerViewEvents(global::Android.Support.V7.Widget.RecyclerView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAttachedToWindow += x, x => _data.ChildViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewDetachedFromWindow += x, x => _data.ChildViewDetachedFromWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InterceptTouchEvent += x, x => _data.InterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RecyclerEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RecyclerEvent += x, x => _data.RecyclerEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RequestDisallowInterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RequestDisallowInterceptTouchEvent += x, x => _data.RequestDisallowInterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); - } -} - -namespace Android.Views -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewEvents Events(this global::Android.Views.View item) => new ViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewGroupEvents Events(this global::Android.Views.ViewGroup item) => new ViewGroupEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewEvents - { - private readonly global::Android.Views.View _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewEvents(global::Android.Views.View data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CapturedPointer => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CapturedPointerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ContextClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextMenuCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CreateContextMenuEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.DragEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.FocusChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GenericMotion => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.GenericMotionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Hover => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.HoverEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.KeyEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LayoutChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LongClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LongClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SystemUiVisibilityChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.SystemUiVisibilityChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Touch => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.TouchEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable UnhandledKeyEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.UnhandledKeyEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.UnhandledKeyEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.UnhandledKeyEvent += x, x => _data.UnhandledKeyEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewGroupEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Views.ViewGroup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewGroupEvents(global::Android.Views.ViewGroup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationEnd => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationEndEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationRepeat => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStart => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationStartEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewAddedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); - } -} - -namespace Android.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TextViewEvents Events(this global::Android.Widget.TextView item) => new TextViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TextViewEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Widget.TextView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TextViewEvents(global::Android.Widget.TextView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AfterTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.AfterTextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BeforeTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EditorAction => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.TextView.EditorActionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Android -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsAppCompatActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity item) => new FormsAppCompatActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsApplicationActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsApplicationActivity item) => new FormsApplicationActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IBorderVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer item) => new IBorderVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDeviceInfoProviderEvents Events(this global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider item) => new IDeviceInfoProviderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ImageButtonRenderer item) => new ImageButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellItemRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IShellItemRenderer item) => new IShellItemRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellObservableFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.IShellObservableFragment item) => new IShellObservableFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.IShellSearchView item) => new IShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ItemsViewRenderer item) => new ItemsViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.Android.MasterDetailRenderer item) => new MasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellContentFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.ShellContentFragment item) => new ShellContentFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellItemRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.ShellItemRendererBase item) => new ShellItemRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSearchView item) => new ShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSectionRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSectionRenderer item) => new ShellSectionRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsAppCompatActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsAppCompatActivityEvents(global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsApplicationActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsApplicationActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsApplicationActivityEvents(global::Xamarin.Forms.Platform.Android.FormsApplicationActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IBorderVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IBorderVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDeviceInfoProviderEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDeviceInfoProviderEvents(global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ImageButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonRendererEvents(global::Xamarin.Forms.Platform.Android.ImageButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellItemRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellItemRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellItemRendererEvents(global::Xamarin.Forms.Platform.Android.IShellItemRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellObservableFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellObservableFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellObservableFragmentEvents(global::Xamarin.Forms.Platform.Android.IShellObservableFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.IShellSearchView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewRendererEvents : global::Android.Support.V7.Widget.RecyclerViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ItemsViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewRendererEvents(global::Xamarin.Forms.Platform.Android.ItemsViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailRendererEvents : global::Android.Support.V4.Widget.DrawerLayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Android.MasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailRendererEvents(global::Xamarin.Forms.Platform.Android.MasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::Android.Support.V4.Widget.NestedScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.Android.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellContentFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellContentFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellContentFragmentEvents(global::Xamarin.Forms.Platform.Android.ShellContentFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellItemRendererBaseEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellItemRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellItemRendererBaseEvents(global::Xamarin.Forms.Platform.Android.ShellItemRendererBase data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.ShellSearchView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSectionRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSectionRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSectionRendererEvents(global::Xamarin.Forms.Platform.Android.ShellSectionRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } -} - -namespace Xamarin.Forms.Platform.Android.FastRenderers -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer item) => new ButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FrameRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer item) => new FrameRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer item) => new ImageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LabelRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer item) => new LabelRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FrameRendererEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FrameRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LabelRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LabelRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.netstandard2.0.approved.txt deleted file mode 100644 index 1e2e745..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.netstandard2.0.approved.txt +++ /dev/null @@ -1,2540 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.tizen40.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.tizen40.approved.txt deleted file mode 100644 index 5ce7ed0..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.tizen40.approved.txt +++ /dev/null @@ -1,3390 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace ElmSharp -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::ElmSharp.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EvasObjectEvents Events(this global::ElmSharp.EvasObject item) => new EvasObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::ElmSharp.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PopupEvents Events(this global::ElmSharp.Popup item) => new PopupEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WidgetEvents Events(this global::ElmSharp.Widget item) => new WidgetEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::ElmSharp.LayoutEvents - { - private readonly global::ElmSharp.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::ElmSharp.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChangedByUser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChangedByUser += x, x => _data.ChangedByUser -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CursorChanged += x, x => _data.CursorChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EvasObjectEvents - { - private readonly global::ElmSharp.EvasObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EvasObjectEvents(global::ElmSharp.EvasObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Deleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Deleted += x, x => _data.Deleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.EvasKeyEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.EvasKeyEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MoreButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MoreButtonPressed += x, x => _data.MoreButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Moved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Moved += x, x => _data.Moved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RenderPost => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RenderPost += x, x => _data.RenderPost -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Resized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Resized += x, x => _data.Resized -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::ElmSharp.WidgetEvents - { - private readonly global::ElmSharp.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::ElmSharp.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ThemeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ThemeChanged += x, x => _data.ThemeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PopupEvents : global::ElmSharp.LayoutEvents - { - private readonly global::ElmSharp.Popup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PopupEvents(global::ElmSharp.Popup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Dismissed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OutsideClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OutsideClicked += x, x => _data.OutsideClicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ShowAnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ShowAnimationFinished += x, x => _data.ShowAnimationFinished -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TimedOut => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TimedOut += x, x => _data.TimedOut -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WidgetEvents : global::ElmSharp.EvasObjectEvents - { - private readonly global::ElmSharp.Widget _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WidgetEvents(global::ElmSharp.Widget data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DefaultPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.DefaultPlatform item) => new DefaultPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static GestureHandlerEvents Events(this global::Xamarin.Forms.Platform.Tizen.GestureHandler item) => new GestureHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITizenPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.ITizenPlatform item) => new ITizenPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LightweightPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.LightweightPlatform item) => new LightweightPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationDrawerEvents Events(this global::Xamarin.Forms.Platform.Tizen.NavigationDrawer item) => new NavigationDrawerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationViewEvents Events(this global::Xamarin.Forms.Platform.Tizen.NavigationView item) => new NavigationViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DefaultPlatformEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.DefaultPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DefaultPlatformEvents(global::Xamarin.Forms.Platform.Tizen.DefaultPlatform data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class GestureHandlerEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.GestureHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public GestureHandlerEvents(global::Xamarin.Forms.Platform.Tizen.GestureHandler data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITizenPlatformEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.ITizenPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITizenPlatformEvents(global::Xamarin.Forms.Platform.Tizen.ITizenPlatform data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LightweightPlatformEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.LightweightPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LightweightPlatformEvents(global::Xamarin.Forms.Platform.Tizen.LightweightPlatform data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationDrawerEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.NavigationDrawer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationDrawerEvents(global::Xamarin.Forms.Platform.Tizen.NavigationDrawer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationViewEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.NavigationView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationViewEvents(global::Xamarin.Forms.Platform.Tizen.NavigationView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MenuItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.GenListItemEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MenuItemSelected += x, x => _data.MenuItemSelected -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen.Native -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BoxEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Box item) => new BoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DateTimePickerDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog item) => new DateTimePickerDialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Dialog item) => new DialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditfieldEntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry item) => new EditfieldEntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDateTimeDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog item) => new IDateTimeDialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Page item) => new PageEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BoxEvents : global::ElmSharp.WidgetEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Box _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BoxEvents(global::Xamarin.Forms.Platform.Tizen.Native.Box data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DateTimePickerDialogEvents : global::Xamarin.Forms.Platform.Tizen.Native.DialogEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DateTimePickerDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DialogEvents : global::ElmSharp.PopupEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Dialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.Dialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Shown += x, x => _data.Shown -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditfieldEntryEvents : global::Xamarin.Forms.Platform.Tizen.Native.EntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditfieldEntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextBlockFocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextBlockFocused += x, x => _data.TextBlockFocused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextBlockUnfocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextBlockUnfocused += x, x => _data.TextBlockUnfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::ElmSharp.EntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDateTimeDialogEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDateTimeDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.IsPresentedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.IsPresentedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable UpdateIsPresentChangeable => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.UpdateIsPresentChangeableEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.UpdateIsPresentChangeableEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.UpdateIsPresentChangeable += x, x => _data.UpdateIsPresentChangeable -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::ElmSharp.LayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Platform.Tizen.Native.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen.Native.Watch -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WatchDataTimePickerDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog item) => new WatchDataTimePickerDialogEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WatchDataTimePickerDialogEvents : global::ElmSharp.PopupEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WatchDataTimePickerDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Platform.Tizen.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Platform.Tizen.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.uap10.0.17763.approved.txt deleted file mode 100644 index 6d38c85..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.uap10.0.17763.approved.txt +++ /dev/null @@ -1,2890 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.UWP -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellRendererCompletedEvents Events(this global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted item) => new EntryCellRendererCompletedEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsFlyoutEvents Events(this global::Xamarin.Forms.Platform.UWP.FormsFlyout item) => new FormsFlyoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer item) => new MasterDetailPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer item) => new NavigationPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperControlEvents Events(this global::Xamarin.Forms.Platform.UWP.StepperControl item) => new StepperControlEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer item) => new TabbedPageRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellRendererCompletedEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellRendererCompletedEvents(global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsFlyoutEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.FormsFlyout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsFlyoutEvents(global::Xamarin.Forms.Platform.UWP.FormsFlyout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OptionSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OptionSelected += x, x => _data.OptionSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageRendererEvents(global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageRendererEvents(global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperControlEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.StepperControl _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperControlEvents(global::Xamarin.Forms.Platform.UWP.StepperControl data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedPageRendererEvents(global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.WinRT -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperControlEvents Events(this global::Xamarin.Forms.Platform.WinRT.StepperControl item) => new StepperControlEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperControlEvents - { - private readonly global::Xamarin.Forms.Platform.WinRT.StepperControl _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperControlEvents(global::Xamarin.Forms.Platform.WinRT.StepperControl data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.xamarinios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.xamarinios10.approved.txt deleted file mode 100644 index e370efc..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.xamarinios10.approved.txt +++ /dev/null @@ -1,3554 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace UIKit -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UIScrollViewEvents Events(this global::UIKit.UIScrollView item) => new UIScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UISplitViewControllerEvents Events(this global::UIKit.UISplitViewController item) => new UISplitViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UITabBarControllerEvents Events(this global::UIKit.UITabBarController item) => new UITabBarControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UIWebViewEvents Events(this global::UIKit.UIWebView item) => new UIWebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UIScrollViewEvents - { - private readonly global::UIKit.UIScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UIScrollViewEvents(global::UIKit.UIScrollView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DecelerationEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DecelerationEnded += x, x => _data.DecelerationEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DecelerationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DecelerationStarted += x, x => _data.DecelerationStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidChangeAdjustedContentInset => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidChangeAdjustedContentInset += x, x => _data.DidChangeAdjustedContentInset -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidZoom => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidZoom += x, x => _data.DidZoom -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DraggingEnded => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.DraggingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.DraggingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DraggingEnded += x, x => _data.DraggingEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DraggingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DraggingStarted += x, x => _data.DraggingStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollAnimationEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollAnimationEnded += x, x => _data.ScrollAnimationEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrolledToTop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrolledToTop += x, x => _data.ScrolledToTop -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillEndDragging => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.WillEndDraggingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.WillEndDraggingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillEndDragging += x, x => _data.WillEndDragging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ZoomingEnded => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.ZoomingEndedEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.ZoomingEndedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ZoomingEnded += x, x => _data.ZoomingEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ZoomingStarted => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIScrollViewZoomingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UIScrollViewZoomingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ZoomingStarted += x, x => _data.ZoomingStarted -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UISplitViewControllerEvents - { - private readonly global::UIKit.UISplitViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UISplitViewControllerEvents(global::UIKit.UISplitViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillChangeDisplayMode => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewControllerDisplayModeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewControllerDisplayModeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillChangeDisplayMode += x, x => _data.WillChangeDisplayMode -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillHideViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewHideEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewHideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillHideViewController += x, x => _data.WillHideViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillPresentViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewPresentEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewPresentEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillPresentViewController += x, x => _data.WillPresentViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillShowViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewShowEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewShowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillShowViewController += x, x => _data.WillShowViewController -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UITabBarControllerEvents - { - private readonly global::UIKit.UITabBarController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UITabBarControllerEvents(global::UIKit.UITabBarController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FinishedCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FinishedCustomizingViewControllers += x, x => _data.FinishedCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnCustomizingViewControllers += x, x => _data.OnCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnEndCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnEndCustomizingViewControllers += x, x => _data.OnEndCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewControllerSelected => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarSelectionEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarSelectionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewControllerSelected += x, x => _data.ViewControllerSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UIWebViewEvents - { - private readonly global::UIKit.UIWebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UIWebViewEvents(global::UIKit.UIWebView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadError => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIWebErrorArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UIWebErrorArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadError += x, x => _data.LoadError -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadFinished += x, x => _data.LoadFinished -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadStarted += x, x => _data.LoadStarted -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.iOS -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellFlyoutContentRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer item) => new IShellFlyoutContentRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchResultsRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer item) => new IShellSearchResultsRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.NavigationRenderer item) => new NavigationRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.PageRenderer item) => new PageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PhoneMasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer item) => new PhoneMasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellFlyoutContentRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer item) => new ShellFlyoutContentRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellRenderer item) => new ShellRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchResultsRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer item) => new ShellSearchResultsRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellTableViewSourceEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellTableViewSource item) => new ShellTableViewSourceEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.TabbedRenderer item) => new TabbedRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabletMasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer item) => new TabletMasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TemplatedCellEvents Events(this global::Xamarin.Forms.Platform.iOS.TemplatedCell item) => new TemplatedCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementTrackerEvents Events(this global::Xamarin.Forms.Platform.iOS.VisualElementTracker item) => new VisualElementTrackerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.WebViewRenderer item) => new WebViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WkWebViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer item) => new WkWebViewRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ElementChanged => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Platform.iOS.ElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.ElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellFlyoutContentRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellFlyoutContentRendererEvents(global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillAppear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillAppear += x, x => _data.WillAppear -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillDisappear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchResultsRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchResultsRendererEvents(global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => - { - void Handler(object sender, object e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.NavigationRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationRendererEvents(global::Xamarin.Forms.Platform.iOS.NavigationRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.PageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageRendererEvents(global::Xamarin.Forms.Platform.iOS.PageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PhoneMasterDetailRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PhoneMasterDetailRendererEvents(global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::UIKit.UIScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellFlyoutContentRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellFlyoutContentRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillAppear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillAppear += x, x => _data.WillAppear -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillDisappear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchResultsRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchResultsRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => - { - void Handler(object sender, object e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellTableViewSourceEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellTableViewSource _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellTableViewSourceEvents(global::Xamarin.Forms.Platform.iOS.ShellTableViewSource data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrolledEvent => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIScrollView>(eventHandler => - { - void Handler(object sender, global::UIKit.UIScrollView e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrolledEvent += x, x => _data.ScrolledEvent -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedRendererEvents : global::UIKit.UITabBarControllerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TabbedRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedRendererEvents(global::Xamarin.Forms.Platform.iOS.TabbedRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabletMasterDetailRendererEvents : global::UIKit.UISplitViewControllerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabletMasterDetailRendererEvents(global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TemplatedCellEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TemplatedCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TemplatedCellEvents(global::Xamarin.Forms.Platform.iOS.TemplatedCell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContentSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContentSizeChanged += x, x => _data.ContentSizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementTrackerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.VisualElementTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementTrackerEvents(global::Xamarin.Forms.Platform.iOS.VisualElementTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NativeControlUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewRendererEvents : global::UIKit.UIWebViewEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.WebViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewRendererEvents(global::Xamarin.Forms.Platform.iOS.WebViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WkWebViewRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WkWebViewRendererEvents(global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.xamarinios1010.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.xamarinios1010.approved.txt deleted file mode 100644 index 27bf853..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.xamarinios1010.approved.txt +++ /dev/null @@ -1,2534 +0,0 @@ - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.xamarinmac20.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.xamarinmac20.approved.txt deleted file mode 100644 index bdb11dc..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.xamarinmac20.approved.txt +++ /dev/null @@ -1,2940 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace AppKit -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NSPageControllerEvents Events(this global::AppKit.NSPageController item) => new NSPageControllerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NSPageControllerEvents - { - private readonly global::AppKit.NSPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NSPageControllerEvents(global::AppKit.NSPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidEndLiveTransition => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidEndLiveTransition += x, x => _data.DidEndLiveTransition -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidTransition => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPageControllerTransitionEventArgs>(eventHandler => - { - void Handler(object sender, global::AppKit.NSPageControllerTransitionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidTransition += x, x => _data.DidTransition -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PrepareViewController => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPageControllerPrepareViewControllerEventArgs>(eventHandler => - { - void Handler(object sender, global::AppKit.NSPageControllerPrepareViewControllerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PrepareViewController += x, x => _data.PrepareViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillStartLiveTransition => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillStartLiveTransition += x, x => _data.WillStartLiveTransition -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.MacOS -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer item) => new MasterDetailPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer item) => new NavigationPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.PageRenderer item) => new PageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer item) => new TabbedPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementTrackerEvents Events(this global::Xamarin.Forms.Platform.MacOS.VisualElementTracker item) => new VisualElementTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents : global::AppKit.NSPageControllerEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.PageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageRendererEvents(global::Xamarin.Forms.Platform.MacOS.PageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementTrackerEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.VisualElementTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementTrackerEvents(global::Xamarin.Forms.Platform.MacOS.VisualElementTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NativeControlUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.xamarinmac2020.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.xamarinmac2020.approved.txt deleted file mode 100644 index 27bf853..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.0.0.497661.xamarinmac2020.approved.txt +++ /dev/null @@ -1,2534 +0,0 @@ - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.monoandroid81.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.monoandroid81.approved.txt deleted file mode 100644 index 5cc77d9..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.monoandroid81.approved.txt +++ /dev/null @@ -1,3930 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Android.Support.V4.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DrawerLayoutEvents Events(this global::Android.Support.V4.Widget.DrawerLayout item) => new DrawerLayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NestedScrollViewEvents Events(this global::Android.Support.V4.Widget.NestedScrollView item) => new NestedScrollViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DrawerLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.DrawerLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DrawerLayoutEvents(global::Android.Support.V4.Widget.DrawerLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerSlide => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NestedScrollViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.NestedScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NestedScrollViewEvents(global::Android.Support.V4.Widget.NestedScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - } -} - -namespace Android.Support.V7.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RecyclerViewEvents Events(this global::Android.Support.V7.Widget.RecyclerView item) => new RecyclerViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RecyclerViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V7.Widget.RecyclerView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RecyclerViewEvents(global::Android.Support.V7.Widget.RecyclerView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAttachedToWindow += x, x => _data.ChildViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewDetachedFromWindow += x, x => _data.ChildViewDetachedFromWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InterceptTouchEvent += x, x => _data.InterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RecyclerEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RecyclerEvent += x, x => _data.RecyclerEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RequestDisallowInterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RequestDisallowInterceptTouchEvent += x, x => _data.RequestDisallowInterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); - } -} - -namespace Android.Views -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewEvents Events(this global::Android.Views.View item) => new ViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewGroupEvents Events(this global::Android.Views.ViewGroup item) => new ViewGroupEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewEvents - { - private readonly global::Android.Views.View _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewEvents(global::Android.Views.View data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CapturedPointer => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CapturedPointerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ContextClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextMenuCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CreateContextMenuEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.DragEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.FocusChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GenericMotion => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.GenericMotionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Hover => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.HoverEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.KeyEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LayoutChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LongClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LongClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SystemUiVisibilityChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.SystemUiVisibilityChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Touch => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.TouchEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewGroupEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Views.ViewGroup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewGroupEvents(global::Android.Views.ViewGroup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationEnd => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationEndEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationRepeat => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStart => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationStartEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewAddedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); - } -} - -namespace Android.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CompoundButtonEvents Events(this global::Android.Widget.CompoundButton item) => new CompoundButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TextViewEvents Events(this global::Android.Widget.TextView item) => new TextViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CompoundButtonEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Android.Widget.CompoundButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CompoundButtonEvents(global::Android.Widget.CompoundButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.CompoundButton.CheckedChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.CompoundButton.CheckedChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChange += x, x => _data.CheckedChange -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TextViewEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Widget.TextView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TextViewEvents(global::Android.Widget.TextView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AfterTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.AfterTextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BeforeTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EditorAction => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.TextView.EditorActionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Android -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase item) => new CheckBoxRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsAppCompatActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity item) => new FormsAppCompatActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsApplicationActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsApplicationActivity item) => new FormsApplicationActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IBorderVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer item) => new IBorderVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDeviceInfoProviderEvents Events(this global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider item) => new IDeviceInfoProviderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ImageButtonRenderer item) => new ImageButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellItemRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IShellItemRenderer item) => new IShellItemRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellObservableFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.IShellObservableFragment item) => new IShellObservableFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.IShellSearchView item) => new IShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ItemsViewRenderer item) => new ItemsViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.Android.MasterDetailRenderer item) => new MasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellContentFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.ShellContentFragment item) => new ShellContentFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellItemRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.ShellItemRendererBase item) => new ShellItemRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSearchView item) => new ShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSectionRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSectionRenderer item) => new ShellSectionRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxRendererBaseEvents : global::Android.Widget.CompoundButtonEvents - { - private readonly global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxRendererBaseEvents(global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsAppCompatActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsAppCompatActivityEvents(global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsApplicationActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsApplicationActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsApplicationActivityEvents(global::Xamarin.Forms.Platform.Android.FormsApplicationActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IBorderVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IBorderVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDeviceInfoProviderEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDeviceInfoProviderEvents(global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ImageButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonRendererEvents(global::Xamarin.Forms.Platform.Android.ImageButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellItemRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellItemRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellItemRendererEvents(global::Xamarin.Forms.Platform.Android.IShellItemRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellObservableFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellObservableFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellObservableFragmentEvents(global::Xamarin.Forms.Platform.Android.IShellObservableFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.IShellSearchView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewRendererEvents : global::Android.Support.V7.Widget.RecyclerViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ItemsViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewRendererEvents(global::Xamarin.Forms.Platform.Android.ItemsViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailRendererEvents : global::Android.Support.V4.Widget.DrawerLayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Android.MasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailRendererEvents(global::Xamarin.Forms.Platform.Android.MasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::Android.Support.V4.Widget.NestedScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.Android.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellContentFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellContentFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellContentFragmentEvents(global::Xamarin.Forms.Platform.Android.ShellContentFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellItemRendererBaseEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellItemRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellItemRendererBaseEvents(global::Xamarin.Forms.Platform.Android.ShellItemRendererBase data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.ShellSearchView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSectionRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSectionRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSectionRendererEvents(global::Xamarin.Forms.Platform.Android.ShellSectionRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } -} - -namespace Xamarin.Forms.Platform.Android.FastRenderers -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer item) => new ButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FrameRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer item) => new FrameRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer item) => new ImageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LabelRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer item) => new LabelRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FrameRendererEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FrameRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LabelRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LabelRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.monoandroid90.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.monoandroid90.approved.txt deleted file mode 100644 index 8799286..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.monoandroid90.approved.txt +++ /dev/null @@ -1,3940 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Android.Support.V4.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DrawerLayoutEvents Events(this global::Android.Support.V4.Widget.DrawerLayout item) => new DrawerLayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NestedScrollViewEvents Events(this global::Android.Support.V4.Widget.NestedScrollView item) => new NestedScrollViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DrawerLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.DrawerLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DrawerLayoutEvents(global::Android.Support.V4.Widget.DrawerLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerSlide => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NestedScrollViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.NestedScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NestedScrollViewEvents(global::Android.Support.V4.Widget.NestedScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - } -} - -namespace Android.Support.V7.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RecyclerViewEvents Events(this global::Android.Support.V7.Widget.RecyclerView item) => new RecyclerViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RecyclerViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V7.Widget.RecyclerView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RecyclerViewEvents(global::Android.Support.V7.Widget.RecyclerView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAttachedToWindow += x, x => _data.ChildViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewDetachedFromWindow += x, x => _data.ChildViewDetachedFromWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InterceptTouchEvent += x, x => _data.InterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RecyclerEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RecyclerEvent += x, x => _data.RecyclerEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RequestDisallowInterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RequestDisallowInterceptTouchEvent += x, x => _data.RequestDisallowInterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); - } -} - -namespace Android.Views -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewEvents Events(this global::Android.Views.View item) => new ViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewGroupEvents Events(this global::Android.Views.ViewGroup item) => new ViewGroupEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewEvents - { - private readonly global::Android.Views.View _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewEvents(global::Android.Views.View data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CapturedPointer => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CapturedPointerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ContextClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextMenuCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CreateContextMenuEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.DragEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.FocusChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GenericMotion => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.GenericMotionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Hover => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.HoverEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.KeyEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LayoutChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LongClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LongClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SystemUiVisibilityChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.SystemUiVisibilityChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Touch => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.TouchEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable UnhandledKeyEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.UnhandledKeyEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.UnhandledKeyEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.UnhandledKeyEvent += x, x => _data.UnhandledKeyEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewGroupEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Views.ViewGroup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewGroupEvents(global::Android.Views.ViewGroup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationEnd => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationEndEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationRepeat => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStart => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationStartEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewAddedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); - } -} - -namespace Android.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CompoundButtonEvents Events(this global::Android.Widget.CompoundButton item) => new CompoundButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TextViewEvents Events(this global::Android.Widget.TextView item) => new TextViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CompoundButtonEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Android.Widget.CompoundButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CompoundButtonEvents(global::Android.Widget.CompoundButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.CompoundButton.CheckedChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.CompoundButton.CheckedChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChange += x, x => _data.CheckedChange -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TextViewEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Widget.TextView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TextViewEvents(global::Android.Widget.TextView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AfterTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.AfterTextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BeforeTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EditorAction => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.TextView.EditorActionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Android -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase item) => new CheckBoxRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsAppCompatActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity item) => new FormsAppCompatActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsApplicationActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsApplicationActivity item) => new FormsApplicationActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IBorderVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer item) => new IBorderVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDeviceInfoProviderEvents Events(this global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider item) => new IDeviceInfoProviderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ImageButtonRenderer item) => new ImageButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellItemRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IShellItemRenderer item) => new IShellItemRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellObservableFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.IShellObservableFragment item) => new IShellObservableFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.IShellSearchView item) => new IShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ItemsViewRenderer item) => new ItemsViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.Android.MasterDetailRenderer item) => new MasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellContentFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.ShellContentFragment item) => new ShellContentFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellItemRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.ShellItemRendererBase item) => new ShellItemRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSearchView item) => new ShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSectionRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSectionRenderer item) => new ShellSectionRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxRendererBaseEvents : global::Android.Widget.CompoundButtonEvents - { - private readonly global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxRendererBaseEvents(global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsAppCompatActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsAppCompatActivityEvents(global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsApplicationActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsApplicationActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsApplicationActivityEvents(global::Xamarin.Forms.Platform.Android.FormsApplicationActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IBorderVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IBorderVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDeviceInfoProviderEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDeviceInfoProviderEvents(global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ImageButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonRendererEvents(global::Xamarin.Forms.Platform.Android.ImageButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellItemRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellItemRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellItemRendererEvents(global::Xamarin.Forms.Platform.Android.IShellItemRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellObservableFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellObservableFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellObservableFragmentEvents(global::Xamarin.Forms.Platform.Android.IShellObservableFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.IShellSearchView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewRendererEvents : global::Android.Support.V7.Widget.RecyclerViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ItemsViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewRendererEvents(global::Xamarin.Forms.Platform.Android.ItemsViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailRendererEvents : global::Android.Support.V4.Widget.DrawerLayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Android.MasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailRendererEvents(global::Xamarin.Forms.Platform.Android.MasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::Android.Support.V4.Widget.NestedScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.Android.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellContentFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellContentFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellContentFragmentEvents(global::Xamarin.Forms.Platform.Android.ShellContentFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellItemRendererBaseEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellItemRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellItemRendererBaseEvents(global::Xamarin.Forms.Platform.Android.ShellItemRendererBase data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.ShellSearchView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSectionRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSectionRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSectionRendererEvents(global::Xamarin.Forms.Platform.Android.ShellSectionRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } -} - -namespace Xamarin.Forms.Platform.Android.FastRenderers -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer item) => new ButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FrameRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer item) => new FrameRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer item) => new ImageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LabelRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer item) => new LabelRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FrameRendererEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FrameRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LabelRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LabelRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.netstandard2.0.approved.txt deleted file mode 100644 index fa912db..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.netstandard2.0.approved.txt +++ /dev/null @@ -1,2571 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.tizen40.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.tizen40.approved.txt deleted file mode 100644 index e82c488..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.tizen40.approved.txt +++ /dev/null @@ -1,3524 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace ElmSharp -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::ElmSharp.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EvasObjectEvents Events(this global::ElmSharp.EvasObject item) => new EvasObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::ElmSharp.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PopupEvents Events(this global::ElmSharp.Popup item) => new PopupEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WidgetEvents Events(this global::ElmSharp.Widget item) => new WidgetEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::ElmSharp.LayoutEvents - { - private readonly global::ElmSharp.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::ElmSharp.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChangedByUser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChangedByUser += x, x => _data.ChangedByUser -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CursorChanged += x, x => _data.CursorChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EvasObjectEvents - { - private readonly global::ElmSharp.EvasObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EvasObjectEvents(global::ElmSharp.EvasObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Deleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Deleted += x, x => _data.Deleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.EvasKeyEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.EvasKeyEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MoreButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MoreButtonPressed += x, x => _data.MoreButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Moved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Moved += x, x => _data.Moved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RenderPost => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RenderPost += x, x => _data.RenderPost -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Resized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Resized += x, x => _data.Resized -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::ElmSharp.WidgetEvents - { - private readonly global::ElmSharp.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::ElmSharp.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ThemeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ThemeChanged += x, x => _data.ThemeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PopupEvents : global::ElmSharp.LayoutEvents - { - private readonly global::ElmSharp.Popup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PopupEvents(global::ElmSharp.Popup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Dismissed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OutsideClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OutsideClicked += x, x => _data.OutsideClicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ShowAnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ShowAnimationFinished += x, x => _data.ShowAnimationFinished -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TimedOut => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TimedOut += x, x => _data.TimedOut -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WidgetEvents : global::ElmSharp.EvasObjectEvents - { - private readonly global::ElmSharp.Widget _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WidgetEvents(global::ElmSharp.Widget data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DefaultPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.DefaultPlatform item) => new DefaultPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static GestureHandlerEvents Events(this global::Xamarin.Forms.Platform.Tizen.GestureHandler item) => new GestureHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITizenPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.ITizenPlatform item) => new ITizenPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LightweightPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.LightweightPlatform item) => new LightweightPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationDrawerEvents Events(this global::Xamarin.Forms.Platform.Tizen.NavigationDrawer item) => new NavigationDrawerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationViewEvents Events(this global::Xamarin.Forms.Platform.Tizen.NavigationView item) => new NavigationViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DefaultPlatformEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.DefaultPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DefaultPlatformEvents(global::Xamarin.Forms.Platform.Tizen.DefaultPlatform data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class GestureHandlerEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.GestureHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public GestureHandlerEvents(global::Xamarin.Forms.Platform.Tizen.GestureHandler data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITizenPlatformEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.ITizenPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITizenPlatformEvents(global::Xamarin.Forms.Platform.Tizen.ITizenPlatform data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LightweightPlatformEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.LightweightPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LightweightPlatformEvents(global::Xamarin.Forms.Platform.Tizen.LightweightPlatform data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationDrawerEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.NavigationDrawer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationDrawerEvents(global::Xamarin.Forms.Platform.Tizen.NavigationDrawer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationViewEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.NavigationView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationViewEvents(global::Xamarin.Forms.Platform.Tizen.NavigationView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MenuItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.GenListItemEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MenuItemSelected += x, x => _data.MenuItemSelected -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen.Native -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BoxEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Box item) => new BoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DateTimePickerDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog item) => new DateTimePickerDialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Dialog item) => new DialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditfieldEntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry item) => new EditfieldEntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDateTimeDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog item) => new IDateTimeDialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IEntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.IEntry item) => new IEntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemAdaptorEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.ItemAdaptor item) => new ItemAdaptorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewHolderEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.ViewHolder item) => new ViewHolderEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BoxEvents : global::ElmSharp.WidgetEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Box _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BoxEvents(global::Xamarin.Forms.Platform.Tizen.Native.Box data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DateTimePickerDialogEvents : global::Xamarin.Forms.Platform.Tizen.Native.DialogEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DateTimePickerDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DialogEvents : global::ElmSharp.PopupEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Dialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.Dialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Shown += x, x => _data.Shown -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditfieldEntryEvents : global::Xamarin.Forms.Platform.Tizen.Native.EntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditfieldEntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextBlockFocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextBlockFocused += x, x => _data.TextBlockFocused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextBlockUnfocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextBlockUnfocused += x, x => _data.TextBlockUnfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::ElmSharp.EntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDateTimeDialogEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDateTimeDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IEntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.IEntry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IEntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.IEntry data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemAdaptorEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.ItemAdaptor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemAdaptorEvents(global::Xamarin.Forms.Platform.Tizen.Native.ItemAdaptor data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.IsPresentedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.IsPresentedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable UpdateIsPresentChangeable => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.UpdateIsPresentChangeableEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.UpdateIsPresentChangeableEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.UpdateIsPresentChangeable += x, x => _data.UpdateIsPresentChangeable -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::ElmSharp.LayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Platform.Tizen.Native.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewHolderEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.ViewHolder _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewHolderEvents(global::Xamarin.Forms.Platform.Tizen.Native.ViewHolder data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RequestSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RequestSelected += x, x => _data.RequestSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen.Native.Watch -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WatchDataTimePickerDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog item) => new WatchDataTimePickerDialogEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WatchDataTimePickerDialogEvents : global::ElmSharp.PopupEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WatchDataTimePickerDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Platform.Tizen.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Platform.Tizen.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.uap10.0.17763.approved.txt deleted file mode 100644 index e4ea806..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.uap10.0.17763.approved.txt +++ /dev/null @@ -1,2921 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.UWP -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellRendererCompletedEvents Events(this global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted item) => new EntryCellRendererCompletedEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsFlyoutEvents Events(this global::Xamarin.Forms.Platform.UWP.FormsFlyout item) => new FormsFlyoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer item) => new MasterDetailPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer item) => new NavigationPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperControlEvents Events(this global::Xamarin.Forms.Platform.UWP.StepperControl item) => new StepperControlEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer item) => new TabbedPageRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellRendererCompletedEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellRendererCompletedEvents(global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsFlyoutEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.FormsFlyout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsFlyoutEvents(global::Xamarin.Forms.Platform.UWP.FormsFlyout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OptionSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OptionSelected += x, x => _data.OptionSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageRendererEvents(global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageRendererEvents(global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperControlEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.StepperControl _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperControlEvents(global::Xamarin.Forms.Platform.UWP.StepperControl data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedPageRendererEvents(global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.WinRT -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperControlEvents Events(this global::Xamarin.Forms.Platform.WinRT.StepperControl item) => new StepperControlEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperControlEvents - { - private readonly global::Xamarin.Forms.Platform.WinRT.StepperControl _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperControlEvents(global::Xamarin.Forms.Platform.WinRT.StepperControl data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.xamarinios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.xamarinios10.approved.txt deleted file mode 100644 index 66aa3c9..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.xamarinios10.approved.txt +++ /dev/null @@ -1,3585 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace UIKit -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UIScrollViewEvents Events(this global::UIKit.UIScrollView item) => new UIScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UISplitViewControllerEvents Events(this global::UIKit.UISplitViewController item) => new UISplitViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UITabBarControllerEvents Events(this global::UIKit.UITabBarController item) => new UITabBarControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UIWebViewEvents Events(this global::UIKit.UIWebView item) => new UIWebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UIScrollViewEvents - { - private readonly global::UIKit.UIScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UIScrollViewEvents(global::UIKit.UIScrollView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DecelerationEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DecelerationEnded += x, x => _data.DecelerationEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DecelerationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DecelerationStarted += x, x => _data.DecelerationStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidChangeAdjustedContentInset => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidChangeAdjustedContentInset += x, x => _data.DidChangeAdjustedContentInset -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidZoom => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidZoom += x, x => _data.DidZoom -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DraggingEnded => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.DraggingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.DraggingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DraggingEnded += x, x => _data.DraggingEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DraggingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DraggingStarted += x, x => _data.DraggingStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollAnimationEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollAnimationEnded += x, x => _data.ScrollAnimationEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrolledToTop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrolledToTop += x, x => _data.ScrolledToTop -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillEndDragging => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.WillEndDraggingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.WillEndDraggingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillEndDragging += x, x => _data.WillEndDragging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ZoomingEnded => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.ZoomingEndedEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.ZoomingEndedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ZoomingEnded += x, x => _data.ZoomingEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ZoomingStarted => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIScrollViewZoomingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UIScrollViewZoomingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ZoomingStarted += x, x => _data.ZoomingStarted -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UISplitViewControllerEvents - { - private readonly global::UIKit.UISplitViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UISplitViewControllerEvents(global::UIKit.UISplitViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillChangeDisplayMode => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewControllerDisplayModeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewControllerDisplayModeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillChangeDisplayMode += x, x => _data.WillChangeDisplayMode -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillHideViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewHideEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewHideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillHideViewController += x, x => _data.WillHideViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillPresentViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewPresentEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewPresentEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillPresentViewController += x, x => _data.WillPresentViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillShowViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewShowEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewShowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillShowViewController += x, x => _data.WillShowViewController -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UITabBarControllerEvents - { - private readonly global::UIKit.UITabBarController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UITabBarControllerEvents(global::UIKit.UITabBarController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FinishedCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FinishedCustomizingViewControllers += x, x => _data.FinishedCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnCustomizingViewControllers += x, x => _data.OnCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnEndCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnEndCustomizingViewControllers += x, x => _data.OnEndCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewControllerSelected => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarSelectionEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarSelectionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewControllerSelected += x, x => _data.ViewControllerSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UIWebViewEvents - { - private readonly global::UIKit.UIWebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UIWebViewEvents(global::UIKit.UIWebView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadError => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIWebErrorArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UIWebErrorArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadError += x, x => _data.LoadError -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadFinished += x, x => _data.LoadFinished -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadStarted += x, x => _data.LoadStarted -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.iOS -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellFlyoutContentRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer item) => new IShellFlyoutContentRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchResultsRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer item) => new IShellSearchResultsRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.NavigationRenderer item) => new NavigationRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.PageRenderer item) => new PageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PhoneMasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer item) => new PhoneMasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellFlyoutContentRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer item) => new ShellFlyoutContentRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellRenderer item) => new ShellRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchResultsRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer item) => new ShellSearchResultsRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellTableViewSourceEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellTableViewSource item) => new ShellTableViewSourceEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.TabbedRenderer item) => new TabbedRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabletMasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer item) => new TabletMasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TemplatedCellEvents Events(this global::Xamarin.Forms.Platform.iOS.TemplatedCell item) => new TemplatedCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementTrackerEvents Events(this global::Xamarin.Forms.Platform.iOS.VisualElementTracker item) => new VisualElementTrackerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.WebViewRenderer item) => new WebViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WkWebViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer item) => new WkWebViewRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ElementChanged => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Platform.iOS.ElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.ElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellFlyoutContentRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellFlyoutContentRendererEvents(global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillAppear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillAppear += x, x => _data.WillAppear -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillDisappear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchResultsRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchResultsRendererEvents(global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => - { - void Handler(object sender, object e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.NavigationRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationRendererEvents(global::Xamarin.Forms.Platform.iOS.NavigationRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.PageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageRendererEvents(global::Xamarin.Forms.Platform.iOS.PageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PhoneMasterDetailRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PhoneMasterDetailRendererEvents(global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::UIKit.UIScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellFlyoutContentRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellFlyoutContentRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillAppear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillAppear += x, x => _data.WillAppear -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillDisappear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchResultsRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchResultsRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => - { - void Handler(object sender, object e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellTableViewSourceEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellTableViewSource _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellTableViewSourceEvents(global::Xamarin.Forms.Platform.iOS.ShellTableViewSource data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrolledEvent => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIScrollView>(eventHandler => - { - void Handler(object sender, global::UIKit.UIScrollView e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrolledEvent += x, x => _data.ScrolledEvent -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedRendererEvents : global::UIKit.UITabBarControllerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TabbedRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedRendererEvents(global::Xamarin.Forms.Platform.iOS.TabbedRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabletMasterDetailRendererEvents : global::UIKit.UISplitViewControllerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabletMasterDetailRendererEvents(global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TemplatedCellEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TemplatedCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TemplatedCellEvents(global::Xamarin.Forms.Platform.iOS.TemplatedCell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContentSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContentSizeChanged += x, x => _data.ContentSizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementTrackerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.VisualElementTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementTrackerEvents(global::Xamarin.Forms.Platform.iOS.VisualElementTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NativeControlUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewRendererEvents : global::UIKit.UIWebViewEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.WebViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewRendererEvents(global::Xamarin.Forms.Platform.iOS.WebViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WkWebViewRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WkWebViewRendererEvents(global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.xamarinmac20.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.xamarinmac20.approved.txt deleted file mode 100644 index 38db6ca..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.1.0.555618.xamarinmac20.approved.txt +++ /dev/null @@ -1,2988 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace AppKit -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NSPageControllerEvents Events(this global::AppKit.NSPageController item) => new NSPageControllerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NSPageControllerEvents - { - private readonly global::AppKit.NSPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NSPageControllerEvents(global::AppKit.NSPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidEndLiveTransition => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidEndLiveTransition += x, x => _data.DidEndLiveTransition -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidTransition => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPageControllerTransitionEventArgs>(eventHandler => - { - void Handler(object sender, global::AppKit.NSPageControllerTransitionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidTransition += x, x => _data.DidTransition -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PrepareViewController => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPageControllerPrepareViewControllerEventArgs>(eventHandler => - { - void Handler(object sender, global::AppKit.NSPageControllerPrepareViewControllerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PrepareViewController += x, x => _data.PrepareViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillStartLiveTransition => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillStartLiveTransition += x, x => _data.WillStartLiveTransition -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.MacOS -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer item) => new MasterDetailPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer item) => new NavigationPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.PageRenderer item) => new PageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer item) => new TabbedPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementTrackerEvents Events(this global::Xamarin.Forms.Platform.MacOS.VisualElementTracker item) => new VisualElementTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents : global::AppKit.NSPageControllerEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.PageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageRendererEvents(global::Xamarin.Forms.Platform.MacOS.PageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementTrackerEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.VisualElementTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementTrackerEvents(global::Xamarin.Forms.Platform.MacOS.VisualElementTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NativeControlUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} - -namespace Xamarin.Forms.Platform.MacOS -{ - /// - /// Wraps delegates events from into Observables. - /// - public abstract partial class FormsApplicationDelegateRx : global::Xamarin.Forms.Platform.MacOS.FormsApplicationDelegate - { - private readonly Pharmacist.Common.SingleAwaitSubject _setupMainAppMenu = new Pharmacist.Common.SingleAwaitSubject(); - /// - /// Gets an observable which signals when the method is invoked. - /// - public global::System.IObservable SetupMainAppMenuObs => _setupMainAppMenu; - /// - public override void SetupMainAppMenu(global::AppKit.NSMenu nativeMenu) => _setupMainAppMenu.OnNext(nativeMenu); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.monoandroid81.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.monoandroid81.approved.txt deleted file mode 100644 index bf26cc4..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.monoandroid81.approved.txt +++ /dev/null @@ -1,3990 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Android.Support.V4.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DrawerLayoutEvents Events(this global::Android.Support.V4.Widget.DrawerLayout item) => new DrawerLayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NestedScrollViewEvents Events(this global::Android.Support.V4.Widget.NestedScrollView item) => new NestedScrollViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DrawerLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.DrawerLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DrawerLayoutEvents(global::Android.Support.V4.Widget.DrawerLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerSlide => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NestedScrollViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.NestedScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NestedScrollViewEvents(global::Android.Support.V4.Widget.NestedScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - } -} - -namespace Android.Support.V7.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RecyclerViewEvents Events(this global::Android.Support.V7.Widget.RecyclerView item) => new RecyclerViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RecyclerViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V7.Widget.RecyclerView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RecyclerViewEvents(global::Android.Support.V7.Widget.RecyclerView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAttachedToWindow += x, x => _data.ChildViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewDetachedFromWindow += x, x => _data.ChildViewDetachedFromWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InterceptTouchEvent += x, x => _data.InterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RecyclerEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RecyclerEvent += x, x => _data.RecyclerEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RequestDisallowInterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RequestDisallowInterceptTouchEvent += x, x => _data.RequestDisallowInterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); - } -} - -namespace Android.Views -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewEvents Events(this global::Android.Views.View item) => new ViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewGroupEvents Events(this global::Android.Views.ViewGroup item) => new ViewGroupEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewEvents - { - private readonly global::Android.Views.View _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewEvents(global::Android.Views.View data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CapturedPointer => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CapturedPointerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ContextClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextMenuCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CreateContextMenuEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.DragEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.FocusChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GenericMotion => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.GenericMotionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Hover => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.HoverEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.KeyEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LayoutChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LongClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LongClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SystemUiVisibilityChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.SystemUiVisibilityChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Touch => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.TouchEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewGroupEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Views.ViewGroup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewGroupEvents(global::Android.Views.ViewGroup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationEnd => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationEndEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationRepeat => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStart => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationStartEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewAddedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); - } -} - -namespace Android.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CompoundButtonEvents Events(this global::Android.Widget.CompoundButton item) => new CompoundButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TextViewEvents Events(this global::Android.Widget.TextView item) => new TextViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CompoundButtonEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Android.Widget.CompoundButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CompoundButtonEvents(global::Android.Widget.CompoundButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.CompoundButton.CheckedChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.CompoundButton.CheckedChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChange += x, x => _data.CheckedChange -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TextViewEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Widget.TextView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TextViewEvents(global::Android.Widget.TextView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AfterTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.AfterTextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BeforeTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EditorAction => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.TextView.EditorActionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Android -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase item) => new CheckBoxRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsAppCompatActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity item) => new FormsAppCompatActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsApplicationActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsApplicationActivity item) => new FormsApplicationActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IBorderVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer item) => new IBorderVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDeviceInfoProviderEvents Events(this global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider item) => new IDeviceInfoProviderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ImageButtonRenderer item) => new ImageButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellItemRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IShellItemRenderer item) => new IShellItemRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellObservableFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.IShellObservableFragment item) => new IShellObservableFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.IShellSearchView item) => new IShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ItemsViewRenderer item) => new ItemsViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.Android.MasterDetailRenderer item) => new MasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellContentFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.ShellContentFragment item) => new ShellContentFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellItemRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.ShellItemRendererBase item) => new ShellItemRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSearchView item) => new ShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSectionRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSectionRenderer item) => new ShellSectionRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxRendererBaseEvents : global::Android.Widget.CompoundButtonEvents - { - private readonly global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxRendererBaseEvents(global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsAppCompatActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsAppCompatActivityEvents(global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsApplicationActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsApplicationActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsApplicationActivityEvents(global::Xamarin.Forms.Platform.Android.FormsApplicationActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IBorderVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IBorderVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDeviceInfoProviderEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDeviceInfoProviderEvents(global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ImageButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonRendererEvents(global::Xamarin.Forms.Platform.Android.ImageButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellItemRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellItemRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellItemRendererEvents(global::Xamarin.Forms.Platform.Android.IShellItemRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellObservableFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellObservableFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellObservableFragmentEvents(global::Xamarin.Forms.Platform.Android.IShellObservableFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.IShellSearchView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewRendererEvents : global::Android.Support.V7.Widget.RecyclerViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ItemsViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewRendererEvents(global::Xamarin.Forms.Platform.Android.ItemsViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailRendererEvents : global::Android.Support.V4.Widget.DrawerLayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Android.MasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailRendererEvents(global::Xamarin.Forms.Platform.Android.MasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::Android.Support.V4.Widget.NestedScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.Android.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellContentFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellContentFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellContentFragmentEvents(global::Xamarin.Forms.Platform.Android.ShellContentFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellItemRendererBaseEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellItemRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellItemRendererBaseEvents(global::Xamarin.Forms.Platform.Android.ShellItemRendererBase data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.ShellSearchView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSectionRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSectionRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSectionRendererEvents(global::Xamarin.Forms.Platform.Android.ShellSectionRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } -} - -namespace Xamarin.Forms.Platform.Android.FastRenderers -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer item) => new ButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FrameRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer item) => new FrameRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer item) => new ImageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LabelRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer item) => new LabelRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FrameRendererEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FrameRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LabelRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LabelRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.monoandroid90.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.monoandroid90.approved.txt deleted file mode 100644 index 384e740..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.monoandroid90.approved.txt +++ /dev/null @@ -1,4000 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Android.Support.V4.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DrawerLayoutEvents Events(this global::Android.Support.V4.Widget.DrawerLayout item) => new DrawerLayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NestedScrollViewEvents Events(this global::Android.Support.V4.Widget.NestedScrollView item) => new NestedScrollViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DrawerLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.DrawerLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DrawerLayoutEvents(global::Android.Support.V4.Widget.DrawerLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerSlide => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NestedScrollViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.NestedScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NestedScrollViewEvents(global::Android.Support.V4.Widget.NestedScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - } -} - -namespace Android.Support.V7.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RecyclerViewEvents Events(this global::Android.Support.V7.Widget.RecyclerView item) => new RecyclerViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RecyclerViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V7.Widget.RecyclerView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RecyclerViewEvents(global::Android.Support.V7.Widget.RecyclerView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAttachedToWindow += x, x => _data.ChildViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewDetachedFromWindow += x, x => _data.ChildViewDetachedFromWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InterceptTouchEvent += x, x => _data.InterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RecyclerEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RecyclerEvent += x, x => _data.RecyclerEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RequestDisallowInterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RequestDisallowInterceptTouchEvent += x, x => _data.RequestDisallowInterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); - } -} - -namespace Android.Views -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewEvents Events(this global::Android.Views.View item) => new ViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewGroupEvents Events(this global::Android.Views.ViewGroup item) => new ViewGroupEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewEvents - { - private readonly global::Android.Views.View _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewEvents(global::Android.Views.View data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CapturedPointer => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CapturedPointerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ContextClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextMenuCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CreateContextMenuEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.DragEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.FocusChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GenericMotion => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.GenericMotionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Hover => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.HoverEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.KeyEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LayoutChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LongClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LongClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SystemUiVisibilityChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.SystemUiVisibilityChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Touch => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.TouchEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable UnhandledKeyEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.UnhandledKeyEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.UnhandledKeyEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.UnhandledKeyEvent += x, x => _data.UnhandledKeyEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewGroupEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Views.ViewGroup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewGroupEvents(global::Android.Views.ViewGroup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationEnd => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationEndEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationRepeat => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStart => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationStartEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewAddedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); - } -} - -namespace Android.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CompoundButtonEvents Events(this global::Android.Widget.CompoundButton item) => new CompoundButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TextViewEvents Events(this global::Android.Widget.TextView item) => new TextViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CompoundButtonEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Android.Widget.CompoundButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CompoundButtonEvents(global::Android.Widget.CompoundButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.CompoundButton.CheckedChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.CompoundButton.CheckedChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChange += x, x => _data.CheckedChange -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TextViewEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Widget.TextView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TextViewEvents(global::Android.Widget.TextView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AfterTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.AfterTextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BeforeTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EditorAction => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.TextView.EditorActionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Android -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase item) => new CheckBoxRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsAppCompatActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity item) => new FormsAppCompatActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsApplicationActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsApplicationActivity item) => new FormsApplicationActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IBorderVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer item) => new IBorderVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDeviceInfoProviderEvents Events(this global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider item) => new IDeviceInfoProviderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ImageButtonRenderer item) => new ImageButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellItemRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IShellItemRenderer item) => new IShellItemRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellObservableFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.IShellObservableFragment item) => new IShellObservableFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.IShellSearchView item) => new IShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ItemsViewRenderer item) => new ItemsViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.Android.MasterDetailRenderer item) => new MasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellContentFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.ShellContentFragment item) => new ShellContentFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellItemRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.ShellItemRendererBase item) => new ShellItemRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSearchView item) => new ShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSectionRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSectionRenderer item) => new ShellSectionRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxRendererBaseEvents : global::Android.Widget.CompoundButtonEvents - { - private readonly global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxRendererBaseEvents(global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsAppCompatActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsAppCompatActivityEvents(global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsApplicationActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsApplicationActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsApplicationActivityEvents(global::Xamarin.Forms.Platform.Android.FormsApplicationActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IBorderVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IBorderVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDeviceInfoProviderEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDeviceInfoProviderEvents(global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ImageButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonRendererEvents(global::Xamarin.Forms.Platform.Android.ImageButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellItemRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellItemRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellItemRendererEvents(global::Xamarin.Forms.Platform.Android.IShellItemRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellObservableFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellObservableFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellObservableFragmentEvents(global::Xamarin.Forms.Platform.Android.IShellObservableFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.IShellSearchView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewRendererEvents : global::Android.Support.V7.Widget.RecyclerViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ItemsViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewRendererEvents(global::Xamarin.Forms.Platform.Android.ItemsViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailRendererEvents : global::Android.Support.V4.Widget.DrawerLayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Android.MasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailRendererEvents(global::Xamarin.Forms.Platform.Android.MasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::Android.Support.V4.Widget.NestedScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.Android.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellContentFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellContentFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellContentFragmentEvents(global::Xamarin.Forms.Platform.Android.ShellContentFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellItemRendererBaseEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellItemRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellItemRendererBaseEvents(global::Xamarin.Forms.Platform.Android.ShellItemRendererBase data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.ShellSearchView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSectionRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSectionRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSectionRendererEvents(global::Xamarin.Forms.Platform.Android.ShellSectionRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } -} - -namespace Xamarin.Forms.Platform.Android.FastRenderers -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer item) => new ButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FrameRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer item) => new FrameRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer item) => new ImageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LabelRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer item) => new LabelRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FrameRendererEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FrameRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LabelRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LabelRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.netstandard2.0.approved.txt deleted file mode 100644 index 9209284..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.netstandard2.0.approved.txt +++ /dev/null @@ -1,2631 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.tizen40.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.tizen40.approved.txt deleted file mode 100644 index 6623efd..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.tizen40.approved.txt +++ /dev/null @@ -1,3584 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace ElmSharp -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::ElmSharp.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EvasObjectEvents Events(this global::ElmSharp.EvasObject item) => new EvasObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::ElmSharp.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PopupEvents Events(this global::ElmSharp.Popup item) => new PopupEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WidgetEvents Events(this global::ElmSharp.Widget item) => new WidgetEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::ElmSharp.LayoutEvents - { - private readonly global::ElmSharp.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::ElmSharp.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChangedByUser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChangedByUser += x, x => _data.ChangedByUser -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CursorChanged += x, x => _data.CursorChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EvasObjectEvents - { - private readonly global::ElmSharp.EvasObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EvasObjectEvents(global::ElmSharp.EvasObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Deleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Deleted += x, x => _data.Deleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.EvasKeyEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.EvasKeyEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MoreButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MoreButtonPressed += x, x => _data.MoreButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Moved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Moved += x, x => _data.Moved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RenderPost => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RenderPost += x, x => _data.RenderPost -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Resized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Resized += x, x => _data.Resized -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::ElmSharp.WidgetEvents - { - private readonly global::ElmSharp.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::ElmSharp.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ThemeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ThemeChanged += x, x => _data.ThemeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PopupEvents : global::ElmSharp.LayoutEvents - { - private readonly global::ElmSharp.Popup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PopupEvents(global::ElmSharp.Popup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Dismissed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OutsideClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OutsideClicked += x, x => _data.OutsideClicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ShowAnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ShowAnimationFinished += x, x => _data.ShowAnimationFinished -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TimedOut => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TimedOut += x, x => _data.TimedOut -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WidgetEvents : global::ElmSharp.EvasObjectEvents - { - private readonly global::ElmSharp.Widget _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WidgetEvents(global::ElmSharp.Widget data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DefaultPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.DefaultPlatform item) => new DefaultPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static GestureHandlerEvents Events(this global::Xamarin.Forms.Platform.Tizen.GestureHandler item) => new GestureHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITizenPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.ITizenPlatform item) => new ITizenPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LightweightPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.LightweightPlatform item) => new LightweightPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationDrawerEvents Events(this global::Xamarin.Forms.Platform.Tizen.NavigationDrawer item) => new NavigationDrawerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationViewEvents Events(this global::Xamarin.Forms.Platform.Tizen.NavigationView item) => new NavigationViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DefaultPlatformEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.DefaultPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DefaultPlatformEvents(global::Xamarin.Forms.Platform.Tizen.DefaultPlatform data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class GestureHandlerEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.GestureHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public GestureHandlerEvents(global::Xamarin.Forms.Platform.Tizen.GestureHandler data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITizenPlatformEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.ITizenPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITizenPlatformEvents(global::Xamarin.Forms.Platform.Tizen.ITizenPlatform data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LightweightPlatformEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.LightweightPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LightweightPlatformEvents(global::Xamarin.Forms.Platform.Tizen.LightweightPlatform data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationDrawerEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.NavigationDrawer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationDrawerEvents(global::Xamarin.Forms.Platform.Tizen.NavigationDrawer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationViewEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.NavigationView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationViewEvents(global::Xamarin.Forms.Platform.Tizen.NavigationView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MenuItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.GenListItemEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MenuItemSelected += x, x => _data.MenuItemSelected -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen.Native -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BoxEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Box item) => new BoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DateTimePickerDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog item) => new DateTimePickerDialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Dialog item) => new DialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditfieldEntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry item) => new EditfieldEntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDateTimeDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog item) => new IDateTimeDialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IEntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.IEntry item) => new IEntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemAdaptorEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.ItemAdaptor item) => new ItemAdaptorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewHolderEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.ViewHolder item) => new ViewHolderEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BoxEvents : global::ElmSharp.WidgetEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Box _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BoxEvents(global::Xamarin.Forms.Platform.Tizen.Native.Box data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DateTimePickerDialogEvents : global::Xamarin.Forms.Platform.Tizen.Native.DialogEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DateTimePickerDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DialogEvents : global::ElmSharp.PopupEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Dialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.Dialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Shown += x, x => _data.Shown -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditfieldEntryEvents : global::Xamarin.Forms.Platform.Tizen.Native.EntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditfieldEntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextBlockFocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextBlockFocused += x, x => _data.TextBlockFocused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextBlockUnfocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextBlockUnfocused += x, x => _data.TextBlockUnfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::ElmSharp.EntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDateTimeDialogEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDateTimeDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IEntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.IEntry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IEntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.IEntry data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemAdaptorEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.ItemAdaptor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemAdaptorEvents(global::Xamarin.Forms.Platform.Tizen.Native.ItemAdaptor data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.IsPresentedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.IsPresentedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable UpdateIsPresentChangeable => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.UpdateIsPresentChangeableEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.UpdateIsPresentChangeableEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.UpdateIsPresentChangeable += x, x => _data.UpdateIsPresentChangeable -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::ElmSharp.LayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Platform.Tizen.Native.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewHolderEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.ViewHolder _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewHolderEvents(global::Xamarin.Forms.Platform.Tizen.Native.ViewHolder data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RequestSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RequestSelected += x, x => _data.RequestSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen.Native.Watch -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WatchDataTimePickerDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog item) => new WatchDataTimePickerDialogEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WatchDataTimePickerDialogEvents : global::ElmSharp.PopupEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WatchDataTimePickerDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.uap10.0.17763.approved.txt deleted file mode 100644 index a6525d7..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.uap10.0.17763.approved.txt +++ /dev/null @@ -1,2981 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.UWP -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellRendererCompletedEvents Events(this global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted item) => new EntryCellRendererCompletedEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsFlyoutEvents Events(this global::Xamarin.Forms.Platform.UWP.FormsFlyout item) => new FormsFlyoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer item) => new MasterDetailPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer item) => new NavigationPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperControlEvents Events(this global::Xamarin.Forms.Platform.UWP.StepperControl item) => new StepperControlEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer item) => new TabbedPageRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellRendererCompletedEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellRendererCompletedEvents(global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsFlyoutEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.FormsFlyout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsFlyoutEvents(global::Xamarin.Forms.Platform.UWP.FormsFlyout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OptionSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OptionSelected += x, x => _data.OptionSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageRendererEvents(global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageRendererEvents(global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperControlEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.StepperControl _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperControlEvents(global::Xamarin.Forms.Platform.UWP.StepperControl data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedPageRendererEvents(global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.WinRT -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperControlEvents Events(this global::Xamarin.Forms.Platform.WinRT.StepperControl item) => new StepperControlEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperControlEvents - { - private readonly global::Xamarin.Forms.Platform.WinRT.StepperControl _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperControlEvents(global::Xamarin.Forms.Platform.WinRT.StepperControl data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.xamarinios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.xamarinios10.approved.txt deleted file mode 100644 index 3143e24..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.xamarinios10.approved.txt +++ /dev/null @@ -1,3645 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace UIKit -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UIScrollViewEvents Events(this global::UIKit.UIScrollView item) => new UIScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UISplitViewControllerEvents Events(this global::UIKit.UISplitViewController item) => new UISplitViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UITabBarControllerEvents Events(this global::UIKit.UITabBarController item) => new UITabBarControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UIWebViewEvents Events(this global::UIKit.UIWebView item) => new UIWebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UIScrollViewEvents - { - private readonly global::UIKit.UIScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UIScrollViewEvents(global::UIKit.UIScrollView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DecelerationEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DecelerationEnded += x, x => _data.DecelerationEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DecelerationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DecelerationStarted += x, x => _data.DecelerationStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidChangeAdjustedContentInset => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidChangeAdjustedContentInset += x, x => _data.DidChangeAdjustedContentInset -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidZoom => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidZoom += x, x => _data.DidZoom -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DraggingEnded => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.DraggingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.DraggingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DraggingEnded += x, x => _data.DraggingEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DraggingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DraggingStarted += x, x => _data.DraggingStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollAnimationEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollAnimationEnded += x, x => _data.ScrollAnimationEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrolledToTop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrolledToTop += x, x => _data.ScrolledToTop -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillEndDragging => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.WillEndDraggingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.WillEndDraggingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillEndDragging += x, x => _data.WillEndDragging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ZoomingEnded => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.ZoomingEndedEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.ZoomingEndedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ZoomingEnded += x, x => _data.ZoomingEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ZoomingStarted => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIScrollViewZoomingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UIScrollViewZoomingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ZoomingStarted += x, x => _data.ZoomingStarted -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UISplitViewControllerEvents - { - private readonly global::UIKit.UISplitViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UISplitViewControllerEvents(global::UIKit.UISplitViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillChangeDisplayMode => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewControllerDisplayModeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewControllerDisplayModeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillChangeDisplayMode += x, x => _data.WillChangeDisplayMode -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillHideViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewHideEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewHideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillHideViewController += x, x => _data.WillHideViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillPresentViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewPresentEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewPresentEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillPresentViewController += x, x => _data.WillPresentViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillShowViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewShowEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewShowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillShowViewController += x, x => _data.WillShowViewController -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UITabBarControllerEvents - { - private readonly global::UIKit.UITabBarController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UITabBarControllerEvents(global::UIKit.UITabBarController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FinishedCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FinishedCustomizingViewControllers += x, x => _data.FinishedCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnCustomizingViewControllers += x, x => _data.OnCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnEndCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnEndCustomizingViewControllers += x, x => _data.OnEndCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewControllerSelected => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarSelectionEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarSelectionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewControllerSelected += x, x => _data.ViewControllerSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UIWebViewEvents - { - private readonly global::UIKit.UIWebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UIWebViewEvents(global::UIKit.UIWebView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadError => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIWebErrorArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UIWebErrorArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadError += x, x => _data.LoadError -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadFinished += x, x => _data.LoadFinished -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadStarted += x, x => _data.LoadStarted -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.iOS -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellFlyoutContentRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer item) => new IShellFlyoutContentRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchResultsRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer item) => new IShellSearchResultsRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.NavigationRenderer item) => new NavigationRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.PageRenderer item) => new PageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PhoneMasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer item) => new PhoneMasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellFlyoutContentRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer item) => new ShellFlyoutContentRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellRenderer item) => new ShellRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchResultsRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer item) => new ShellSearchResultsRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellTableViewSourceEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellTableViewSource item) => new ShellTableViewSourceEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.TabbedRenderer item) => new TabbedRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabletMasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer item) => new TabletMasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TemplatedCellEvents Events(this global::Xamarin.Forms.Platform.iOS.TemplatedCell item) => new TemplatedCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementTrackerEvents Events(this global::Xamarin.Forms.Platform.iOS.VisualElementTracker item) => new VisualElementTrackerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.WebViewRenderer item) => new WebViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WkWebViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer item) => new WkWebViewRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ElementChanged => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Platform.iOS.ElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.ElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellFlyoutContentRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellFlyoutContentRendererEvents(global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillAppear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillAppear += x, x => _data.WillAppear -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillDisappear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchResultsRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchResultsRendererEvents(global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => - { - void Handler(object sender, object e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.NavigationRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationRendererEvents(global::Xamarin.Forms.Platform.iOS.NavigationRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.PageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageRendererEvents(global::Xamarin.Forms.Platform.iOS.PageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PhoneMasterDetailRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PhoneMasterDetailRendererEvents(global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::UIKit.UIScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellFlyoutContentRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellFlyoutContentRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillAppear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillAppear += x, x => _data.WillAppear -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillDisappear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchResultsRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchResultsRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => - { - void Handler(object sender, object e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellTableViewSourceEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellTableViewSource _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellTableViewSourceEvents(global::Xamarin.Forms.Platform.iOS.ShellTableViewSource data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrolledEvent => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIScrollView>(eventHandler => - { - void Handler(object sender, global::UIKit.UIScrollView e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrolledEvent += x, x => _data.ScrolledEvent -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedRendererEvents : global::UIKit.UITabBarControllerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TabbedRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedRendererEvents(global::Xamarin.Forms.Platform.iOS.TabbedRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabletMasterDetailRendererEvents : global::UIKit.UISplitViewControllerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabletMasterDetailRendererEvents(global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TemplatedCellEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TemplatedCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TemplatedCellEvents(global::Xamarin.Forms.Platform.iOS.TemplatedCell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContentSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContentSizeChanged += x, x => _data.ContentSizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementTrackerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.VisualElementTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementTrackerEvents(global::Xamarin.Forms.Platform.iOS.VisualElementTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NativeControlUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewRendererEvents : global::UIKit.UIWebViewEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.WebViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewRendererEvents(global::Xamarin.Forms.Platform.iOS.WebViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WkWebViewRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WkWebViewRendererEvents(global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.xamarinmac20.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.xamarinmac20.approved.txt deleted file mode 100644 index f4cb566..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.709249.xamarinmac20.approved.txt +++ /dev/null @@ -1,3048 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace AppKit -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NSPageControllerEvents Events(this global::AppKit.NSPageController item) => new NSPageControllerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NSPageControllerEvents - { - private readonly global::AppKit.NSPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NSPageControllerEvents(global::AppKit.NSPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidEndLiveTransition => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidEndLiveTransition += x, x => _data.DidEndLiveTransition -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidTransition => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPageControllerTransitionEventArgs>(eventHandler => - { - void Handler(object sender, global::AppKit.NSPageControllerTransitionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidTransition += x, x => _data.DidTransition -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PrepareViewController => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPageControllerPrepareViewControllerEventArgs>(eventHandler => - { - void Handler(object sender, global::AppKit.NSPageControllerPrepareViewControllerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PrepareViewController += x, x => _data.PrepareViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillStartLiveTransition => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillStartLiveTransition += x, x => _data.WillStartLiveTransition -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.MacOS -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer item) => new MasterDetailPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer item) => new NavigationPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.PageRenderer item) => new PageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer item) => new TabbedPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementTrackerEvents Events(this global::Xamarin.Forms.Platform.MacOS.VisualElementTracker item) => new VisualElementTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents : global::AppKit.NSPageControllerEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.PageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageRendererEvents(global::Xamarin.Forms.Platform.MacOS.PageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementTrackerEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.VisualElementTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementTrackerEvents(global::Xamarin.Forms.Platform.MacOS.VisualElementTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NativeControlUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} - -namespace Xamarin.Forms.Platform.MacOS -{ - /// - /// Wraps delegates events from into Observables. - /// - public abstract partial class FormsApplicationDelegateRx : global::Xamarin.Forms.Platform.MacOS.FormsApplicationDelegate - { - private readonly Pharmacist.Common.SingleAwaitSubject _setupMainAppMenu = new Pharmacist.Common.SingleAwaitSubject(); - /// - /// Gets an observable which signals when the method is invoked. - /// - public global::System.IObservable SetupMainAppMenuObs => _setupMainAppMenu; - /// - public override void SetupMainAppMenu(global::AppKit.NSMenu nativeMenu) => _setupMainAppMenu.OnNext(nativeMenu); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.monoandroid81.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.monoandroid81.approved.txt deleted file mode 100644 index 57feef0..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.monoandroid81.approved.txt +++ /dev/null @@ -1,3991 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Android.Support.V4.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DrawerLayoutEvents Events(this global::Android.Support.V4.Widget.DrawerLayout item) => new DrawerLayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NestedScrollViewEvents Events(this global::Android.Support.V4.Widget.NestedScrollView item) => new NestedScrollViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DrawerLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.DrawerLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DrawerLayoutEvents(global::Android.Support.V4.Widget.DrawerLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerSlide => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NestedScrollViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.NestedScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NestedScrollViewEvents(global::Android.Support.V4.Widget.NestedScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - } -} - -namespace Android.Support.V7.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RecyclerViewEvents Events(this global::Android.Support.V7.Widget.RecyclerView item) => new RecyclerViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RecyclerViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V7.Widget.RecyclerView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RecyclerViewEvents(global::Android.Support.V7.Widget.RecyclerView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAttachedToWindow += x, x => _data.ChildViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewDetachedFromWindow += x, x => _data.ChildViewDetachedFromWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InterceptTouchEvent += x, x => _data.InterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RecyclerEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RecyclerEvent += x, x => _data.RecyclerEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RequestDisallowInterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RequestDisallowInterceptTouchEvent += x, x => _data.RequestDisallowInterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); - } -} - -namespace Android.Views -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewEvents Events(this global::Android.Views.View item) => new ViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewGroupEvents Events(this global::Android.Views.ViewGroup item) => new ViewGroupEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewEvents - { - private readonly global::Android.Views.View _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewEvents(global::Android.Views.View data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CapturedPointer => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CapturedPointerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ContextClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextMenuCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CreateContextMenuEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.DragEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.FocusChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GenericMotion => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.GenericMotionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Hover => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.HoverEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.KeyEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LayoutChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LongClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LongClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SystemUiVisibilityChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.SystemUiVisibilityChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Touch => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.TouchEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewGroupEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Views.ViewGroup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewGroupEvents(global::Android.Views.ViewGroup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationEnd => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationEndEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationRepeat => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStart => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationStartEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewAddedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); - } -} - -namespace Android.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CompoundButtonEvents Events(this global::Android.Widget.CompoundButton item) => new CompoundButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TextViewEvents Events(this global::Android.Widget.TextView item) => new TextViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CompoundButtonEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Android.Widget.CompoundButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CompoundButtonEvents(global::Android.Widget.CompoundButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.CompoundButton.CheckedChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.CompoundButton.CheckedChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChange += x, x => _data.CheckedChange -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TextViewEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Widget.TextView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TextViewEvents(global::Android.Widget.TextView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AfterTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.AfterTextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BeforeTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EditorAction => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.TextView.EditorActionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Android -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase item) => new CheckBoxRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsAppCompatActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity item) => new FormsAppCompatActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsApplicationActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsApplicationActivity item) => new FormsApplicationActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IBorderVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer item) => new IBorderVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDeviceInfoProviderEvents Events(this global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider item) => new IDeviceInfoProviderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ImageButtonRenderer item) => new ImageButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellItemRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IShellItemRenderer item) => new IShellItemRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellObservableFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.IShellObservableFragment item) => new IShellObservableFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.IShellSearchView item) => new IShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ItemsViewRenderer item) => new ItemsViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.Android.MasterDetailRenderer item) => new MasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellContentFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.ShellContentFragment item) => new ShellContentFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellItemRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.ShellItemRendererBase item) => new ShellItemRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSearchView item) => new ShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSectionRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSectionRenderer item) => new ShellSectionRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxRendererBaseEvents : global::Android.Widget.CompoundButtonEvents - { - private readonly global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxRendererBaseEvents(global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsAppCompatActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsAppCompatActivityEvents(global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsApplicationActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsApplicationActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsApplicationActivityEvents(global::Xamarin.Forms.Platform.Android.FormsApplicationActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IBorderVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IBorderVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDeviceInfoProviderEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDeviceInfoProviderEvents(global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ImageButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonRendererEvents(global::Xamarin.Forms.Platform.Android.ImageButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellItemRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellItemRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellItemRendererEvents(global::Xamarin.Forms.Platform.Android.IShellItemRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellObservableFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellObservableFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellObservableFragmentEvents(global::Xamarin.Forms.Platform.Android.IShellObservableFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.IShellSearchView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewRendererEvents : global::Android.Support.V7.Widget.RecyclerViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ItemsViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewRendererEvents(global::Xamarin.Forms.Platform.Android.ItemsViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailRendererEvents : global::Android.Support.V4.Widget.DrawerLayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Android.MasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailRendererEvents(global::Xamarin.Forms.Platform.Android.MasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::Android.Support.V4.Widget.NestedScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.Android.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellContentFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellContentFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellContentFragmentEvents(global::Xamarin.Forms.Platform.Android.ShellContentFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellItemRendererBaseEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellItemRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellItemRendererBaseEvents(global::Xamarin.Forms.Platform.Android.ShellItemRendererBase data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.ShellSearchView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSectionRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSectionRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSectionRendererEvents(global::Xamarin.Forms.Platform.Android.ShellSectionRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } -} - -namespace Xamarin.Forms.Platform.Android.FastRenderers -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer item) => new ButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FrameRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer item) => new FrameRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer item) => new ImageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LabelRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer item) => new LabelRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FrameRendererEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FrameRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LabelRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LabelRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.monoandroid90.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.monoandroid90.approved.txt deleted file mode 100644 index 12ae36a..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.monoandroid90.approved.txt +++ /dev/null @@ -1,4001 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Android.Support.V4.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DrawerLayoutEvents Events(this global::Android.Support.V4.Widget.DrawerLayout item) => new DrawerLayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NestedScrollViewEvents Events(this global::Android.Support.V4.Widget.NestedScrollView item) => new NestedScrollViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DrawerLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.DrawerLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DrawerLayoutEvents(global::Android.Support.V4.Widget.DrawerLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerSlide => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NestedScrollViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.NestedScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NestedScrollViewEvents(global::Android.Support.V4.Widget.NestedScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - } -} - -namespace Android.Support.V7.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RecyclerViewEvents Events(this global::Android.Support.V7.Widget.RecyclerView item) => new RecyclerViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RecyclerViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V7.Widget.RecyclerView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RecyclerViewEvents(global::Android.Support.V7.Widget.RecyclerView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAttachedToWindow += x, x => _data.ChildViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.ChildViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewDetachedFromWindow += x, x => _data.ChildViewDetachedFromWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.InterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InterceptTouchEvent += x, x => _data.InterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RecyclerEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RecyclerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RecyclerEvent += x, x => _data.RecyclerEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RequestDisallowInterceptTouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.RequestDisallowInterceptTouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RequestDisallowInterceptTouchEvent += x, x => _data.RequestDisallowInterceptTouchEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TouchEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V7.Widget.RecyclerView.TouchEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TouchEvent += x, x => _data.TouchEvent -= x); - } -} - -namespace Android.Views -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewEvents Events(this global::Android.Views.View item) => new ViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewGroupEvents Events(this global::Android.Views.ViewGroup item) => new ViewGroupEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewEvents - { - private readonly global::Android.Views.View _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewEvents(global::Android.Views.View data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CapturedPointer => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CapturedPointerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ContextClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextMenuCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CreateContextMenuEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.DragEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.FocusChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GenericMotion => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.GenericMotionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Hover => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.HoverEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.KeyEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LayoutChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LongClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LongClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SystemUiVisibilityChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.SystemUiVisibilityChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Touch => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.TouchEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable UnhandledKeyEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.UnhandledKeyEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.UnhandledKeyEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.UnhandledKeyEvent += x, x => _data.UnhandledKeyEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewGroupEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Views.ViewGroup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewGroupEvents(global::Android.Views.ViewGroup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationEnd => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationEndEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationRepeat => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStart => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationStartEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewAddedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); - } -} - -namespace Android.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CompoundButtonEvents Events(this global::Android.Widget.CompoundButton item) => new CompoundButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TextViewEvents Events(this global::Android.Widget.TextView item) => new TextViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CompoundButtonEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Android.Widget.CompoundButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CompoundButtonEvents(global::Android.Widget.CompoundButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.CompoundButton.CheckedChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.CompoundButton.CheckedChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChange += x, x => _data.CheckedChange -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TextViewEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Widget.TextView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TextViewEvents(global::Android.Widget.TextView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AfterTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.AfterTextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BeforeTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EditorAction => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.TextView.EditorActionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Android -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase item) => new CheckBoxRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsAppCompatActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity item) => new FormsAppCompatActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsApplicationActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsApplicationActivity item) => new FormsApplicationActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IBorderVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer item) => new IBorderVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDeviceInfoProviderEvents Events(this global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider item) => new IDeviceInfoProviderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ImageButtonRenderer item) => new ImageButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellItemRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IShellItemRenderer item) => new IShellItemRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellObservableFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.IShellObservableFragment item) => new IShellObservableFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.IShellSearchView item) => new IShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ItemsViewRenderer item) => new ItemsViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.Android.MasterDetailRenderer item) => new MasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellContentFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.ShellContentFragment item) => new ShellContentFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellItemRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.ShellItemRendererBase item) => new ShellItemRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSearchView item) => new ShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSectionRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSectionRenderer item) => new ShellSectionRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxRendererBaseEvents : global::Android.Widget.CompoundButtonEvents - { - private readonly global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxRendererBaseEvents(global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsAppCompatActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsAppCompatActivityEvents(global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsApplicationActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsApplicationActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsApplicationActivityEvents(global::Xamarin.Forms.Platform.Android.FormsApplicationActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IBorderVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IBorderVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDeviceInfoProviderEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDeviceInfoProviderEvents(global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ImageButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonRendererEvents(global::Xamarin.Forms.Platform.Android.ImageButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellItemRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellItemRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellItemRendererEvents(global::Xamarin.Forms.Platform.Android.IShellItemRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellObservableFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellObservableFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellObservableFragmentEvents(global::Xamarin.Forms.Platform.Android.IShellObservableFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.IShellSearchView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewRendererEvents : global::Android.Support.V7.Widget.RecyclerViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ItemsViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewRendererEvents(global::Xamarin.Forms.Platform.Android.ItemsViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailRendererEvents : global::Android.Support.V4.Widget.DrawerLayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Android.MasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailRendererEvents(global::Xamarin.Forms.Platform.Android.MasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::Android.Support.V4.Widget.NestedScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.Android.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellContentFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellContentFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellContentFragmentEvents(global::Xamarin.Forms.Platform.Android.ShellContentFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellItemRendererBaseEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellItemRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellItemRendererBaseEvents(global::Xamarin.Forms.Platform.Android.ShellItemRendererBase data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.ShellSearchView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSectionRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSectionRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSectionRendererEvents(global::Xamarin.Forms.Platform.Android.ShellSectionRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } -} - -namespace Xamarin.Forms.Platform.Android.FastRenderers -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer item) => new ButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FrameRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer item) => new FrameRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer item) => new ImageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LabelRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer item) => new LabelRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FrameRendererEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FrameRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LabelRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LabelRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.netstandard2.0.approved.txt deleted file mode 100644 index 192038c..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.netstandard2.0.approved.txt +++ /dev/null @@ -1,2632 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.tizen40.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.tizen40.approved.txt deleted file mode 100644 index d9e6f0b..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.tizen40.approved.txt +++ /dev/null @@ -1,3585 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace ElmSharp -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::ElmSharp.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EvasObjectEvents Events(this global::ElmSharp.EvasObject item) => new EvasObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::ElmSharp.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PopupEvents Events(this global::ElmSharp.Popup item) => new PopupEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WidgetEvents Events(this global::ElmSharp.Widget item) => new WidgetEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::ElmSharp.LayoutEvents - { - private readonly global::ElmSharp.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::ElmSharp.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChangedByUser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChangedByUser += x, x => _data.ChangedByUser -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CursorChanged += x, x => _data.CursorChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EvasObjectEvents - { - private readonly global::ElmSharp.EvasObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EvasObjectEvents(global::ElmSharp.EvasObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Deleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Deleted += x, x => _data.Deleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.EvasKeyEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.EvasKeyEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MoreButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MoreButtonPressed += x, x => _data.MoreButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Moved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Moved += x, x => _data.Moved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RenderPost => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RenderPost += x, x => _data.RenderPost -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Resized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Resized += x, x => _data.Resized -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::ElmSharp.WidgetEvents - { - private readonly global::ElmSharp.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::ElmSharp.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ThemeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ThemeChanged += x, x => _data.ThemeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PopupEvents : global::ElmSharp.LayoutEvents - { - private readonly global::ElmSharp.Popup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PopupEvents(global::ElmSharp.Popup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Dismissed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OutsideClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OutsideClicked += x, x => _data.OutsideClicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ShowAnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ShowAnimationFinished += x, x => _data.ShowAnimationFinished -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TimedOut => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TimedOut += x, x => _data.TimedOut -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WidgetEvents : global::ElmSharp.EvasObjectEvents - { - private readonly global::ElmSharp.Widget _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WidgetEvents(global::ElmSharp.Widget data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DefaultPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.DefaultPlatform item) => new DefaultPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static GestureHandlerEvents Events(this global::Xamarin.Forms.Platform.Tizen.GestureHandler item) => new GestureHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITizenPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.ITizenPlatform item) => new ITizenPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LightweightPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.LightweightPlatform item) => new LightweightPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationDrawerEvents Events(this global::Xamarin.Forms.Platform.Tizen.NavigationDrawer item) => new NavigationDrawerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationViewEvents Events(this global::Xamarin.Forms.Platform.Tizen.NavigationView item) => new NavigationViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DefaultPlatformEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.DefaultPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DefaultPlatformEvents(global::Xamarin.Forms.Platform.Tizen.DefaultPlatform data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class GestureHandlerEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.GestureHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public GestureHandlerEvents(global::Xamarin.Forms.Platform.Tizen.GestureHandler data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITizenPlatformEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.ITizenPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITizenPlatformEvents(global::Xamarin.Forms.Platform.Tizen.ITizenPlatform data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LightweightPlatformEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.LightweightPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LightweightPlatformEvents(global::Xamarin.Forms.Platform.Tizen.LightweightPlatform data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationDrawerEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.NavigationDrawer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationDrawerEvents(global::Xamarin.Forms.Platform.Tizen.NavigationDrawer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationViewEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.NavigationView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationViewEvents(global::Xamarin.Forms.Platform.Tizen.NavigationView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MenuItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.GenListItemEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MenuItemSelected += x, x => _data.MenuItemSelected -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen.Native -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BoxEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Box item) => new BoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DateTimePickerDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog item) => new DateTimePickerDialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Dialog item) => new DialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditfieldEntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry item) => new EditfieldEntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDateTimeDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog item) => new IDateTimeDialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IEntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.IEntry item) => new IEntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemAdaptorEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.ItemAdaptor item) => new ItemAdaptorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewHolderEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.ViewHolder item) => new ViewHolderEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BoxEvents : global::ElmSharp.WidgetEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Box _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BoxEvents(global::Xamarin.Forms.Platform.Tizen.Native.Box data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DateTimePickerDialogEvents : global::Xamarin.Forms.Platform.Tizen.Native.DialogEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DateTimePickerDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DialogEvents : global::ElmSharp.PopupEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Dialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.Dialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Shown += x, x => _data.Shown -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditfieldEntryEvents : global::Xamarin.Forms.Platform.Tizen.Native.EntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditfieldEntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextBlockFocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextBlockFocused += x, x => _data.TextBlockFocused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextBlockUnfocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextBlockUnfocused += x, x => _data.TextBlockUnfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::ElmSharp.EntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDateTimeDialogEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDateTimeDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IEntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.IEntry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IEntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.IEntry data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemAdaptorEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.ItemAdaptor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemAdaptorEvents(global::Xamarin.Forms.Platform.Tizen.Native.ItemAdaptor data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.IsPresentedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.IsPresentedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable UpdateIsPresentChangeable => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.UpdateIsPresentChangeableEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.UpdateIsPresentChangeableEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.UpdateIsPresentChangeable += x, x => _data.UpdateIsPresentChangeable -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::ElmSharp.LayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Platform.Tizen.Native.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewHolderEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.ViewHolder _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewHolderEvents(global::Xamarin.Forms.Platform.Tizen.Native.ViewHolder data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RequestSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RequestSelected += x, x => _data.RequestSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen.Native.Watch -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WatchDataTimePickerDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog item) => new WatchDataTimePickerDialogEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WatchDataTimePickerDialogEvents : global::ElmSharp.PopupEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WatchDataTimePickerDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.uap10.0.17763.approved.txt deleted file mode 100644 index d52e89c..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.uap10.0.17763.approved.txt +++ /dev/null @@ -1,2982 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.UWP -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellRendererCompletedEvents Events(this global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted item) => new EntryCellRendererCompletedEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsFlyoutEvents Events(this global::Xamarin.Forms.Platform.UWP.FormsFlyout item) => new FormsFlyoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer item) => new MasterDetailPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer item) => new NavigationPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperControlEvents Events(this global::Xamarin.Forms.Platform.UWP.StepperControl item) => new StepperControlEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer item) => new TabbedPageRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellRendererCompletedEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellRendererCompletedEvents(global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsFlyoutEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.FormsFlyout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsFlyoutEvents(global::Xamarin.Forms.Platform.UWP.FormsFlyout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OptionSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OptionSelected += x, x => _data.OptionSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageRendererEvents(global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageRendererEvents(global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperControlEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.StepperControl _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperControlEvents(global::Xamarin.Forms.Platform.UWP.StepperControl data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedPageRendererEvents(global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.WinRT -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperControlEvents Events(this global::Xamarin.Forms.Platform.WinRT.StepperControl item) => new StepperControlEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperControlEvents - { - private readonly global::Xamarin.Forms.Platform.WinRT.StepperControl _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperControlEvents(global::Xamarin.Forms.Platform.WinRT.StepperControl data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.xamarinios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.xamarinios10.approved.txt deleted file mode 100644 index e7dad76..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.xamarinios10.approved.txt +++ /dev/null @@ -1,3646 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace UIKit -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UIScrollViewEvents Events(this global::UIKit.UIScrollView item) => new UIScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UISplitViewControllerEvents Events(this global::UIKit.UISplitViewController item) => new UISplitViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UITabBarControllerEvents Events(this global::UIKit.UITabBarController item) => new UITabBarControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UIWebViewEvents Events(this global::UIKit.UIWebView item) => new UIWebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UIScrollViewEvents - { - private readonly global::UIKit.UIScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UIScrollViewEvents(global::UIKit.UIScrollView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DecelerationEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DecelerationEnded += x, x => _data.DecelerationEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DecelerationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DecelerationStarted += x, x => _data.DecelerationStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidChangeAdjustedContentInset => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidChangeAdjustedContentInset += x, x => _data.DidChangeAdjustedContentInset -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidZoom => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidZoom += x, x => _data.DidZoom -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DraggingEnded => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.DraggingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.DraggingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DraggingEnded += x, x => _data.DraggingEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DraggingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DraggingStarted += x, x => _data.DraggingStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollAnimationEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollAnimationEnded += x, x => _data.ScrollAnimationEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrolledToTop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrolledToTop += x, x => _data.ScrolledToTop -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillEndDragging => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.WillEndDraggingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.WillEndDraggingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillEndDragging += x, x => _data.WillEndDragging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ZoomingEnded => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.ZoomingEndedEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.ZoomingEndedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ZoomingEnded += x, x => _data.ZoomingEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ZoomingStarted => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIScrollViewZoomingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UIScrollViewZoomingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ZoomingStarted += x, x => _data.ZoomingStarted -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UISplitViewControllerEvents - { - private readonly global::UIKit.UISplitViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UISplitViewControllerEvents(global::UIKit.UISplitViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillChangeDisplayMode => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewControllerDisplayModeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewControllerDisplayModeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillChangeDisplayMode += x, x => _data.WillChangeDisplayMode -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillHideViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewHideEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewHideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillHideViewController += x, x => _data.WillHideViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillPresentViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewPresentEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewPresentEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillPresentViewController += x, x => _data.WillPresentViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillShowViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewShowEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewShowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillShowViewController += x, x => _data.WillShowViewController -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UITabBarControllerEvents - { - private readonly global::UIKit.UITabBarController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UITabBarControllerEvents(global::UIKit.UITabBarController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FinishedCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FinishedCustomizingViewControllers += x, x => _data.FinishedCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnCustomizingViewControllers += x, x => _data.OnCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnEndCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnEndCustomizingViewControllers += x, x => _data.OnEndCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewControllerSelected => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarSelectionEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarSelectionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewControllerSelected += x, x => _data.ViewControllerSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UIWebViewEvents - { - private readonly global::UIKit.UIWebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UIWebViewEvents(global::UIKit.UIWebView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadError => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIWebErrorArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UIWebErrorArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadError += x, x => _data.LoadError -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadFinished += x, x => _data.LoadFinished -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadStarted += x, x => _data.LoadStarted -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.iOS -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellFlyoutContentRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer item) => new IShellFlyoutContentRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchResultsRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer item) => new IShellSearchResultsRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.NavigationRenderer item) => new NavigationRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.PageRenderer item) => new PageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PhoneMasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer item) => new PhoneMasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellFlyoutContentRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer item) => new ShellFlyoutContentRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellRenderer item) => new ShellRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchResultsRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer item) => new ShellSearchResultsRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellTableViewSourceEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellTableViewSource item) => new ShellTableViewSourceEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.TabbedRenderer item) => new TabbedRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabletMasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer item) => new TabletMasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TemplatedCellEvents Events(this global::Xamarin.Forms.Platform.iOS.TemplatedCell item) => new TemplatedCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementTrackerEvents Events(this global::Xamarin.Forms.Platform.iOS.VisualElementTracker item) => new VisualElementTrackerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.WebViewRenderer item) => new WebViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WkWebViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer item) => new WkWebViewRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ElementChanged => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Platform.iOS.ElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.ElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellFlyoutContentRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellFlyoutContentRendererEvents(global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillAppear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillAppear += x, x => _data.WillAppear -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillDisappear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchResultsRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchResultsRendererEvents(global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => - { - void Handler(object sender, object e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.NavigationRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationRendererEvents(global::Xamarin.Forms.Platform.iOS.NavigationRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.PageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageRendererEvents(global::Xamarin.Forms.Platform.iOS.PageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PhoneMasterDetailRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PhoneMasterDetailRendererEvents(global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::UIKit.UIScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellFlyoutContentRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellFlyoutContentRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillAppear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillAppear += x, x => _data.WillAppear -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillDisappear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchResultsRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchResultsRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => - { - void Handler(object sender, object e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellTableViewSourceEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellTableViewSource _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellTableViewSourceEvents(global::Xamarin.Forms.Platform.iOS.ShellTableViewSource data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrolledEvent => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIScrollView>(eventHandler => - { - void Handler(object sender, global::UIKit.UIScrollView e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrolledEvent += x, x => _data.ScrolledEvent -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedRendererEvents : global::UIKit.UITabBarControllerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TabbedRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedRendererEvents(global::Xamarin.Forms.Platform.iOS.TabbedRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabletMasterDetailRendererEvents : global::UIKit.UISplitViewControllerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabletMasterDetailRendererEvents(global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TemplatedCellEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TemplatedCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TemplatedCellEvents(global::Xamarin.Forms.Platform.iOS.TemplatedCell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContentSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContentSizeChanged += x, x => _data.ContentSizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementTrackerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.VisualElementTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementTrackerEvents(global::Xamarin.Forms.Platform.iOS.VisualElementTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NativeControlUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewRendererEvents : global::UIKit.UIWebViewEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.WebViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewRendererEvents(global::Xamarin.Forms.Platform.iOS.WebViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WkWebViewRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WkWebViewRendererEvents(global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.xamarinmac20.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.xamarinmac20.approved.txt deleted file mode 100644 index 1c5785d..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.2.0.815419.xamarinmac20.approved.txt +++ /dev/null @@ -1,3049 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace AppKit -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NSPageControllerEvents Events(this global::AppKit.NSPageController item) => new NSPageControllerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NSPageControllerEvents - { - private readonly global::AppKit.NSPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NSPageControllerEvents(global::AppKit.NSPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidEndLiveTransition => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidEndLiveTransition += x, x => _data.DidEndLiveTransition -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidTransition => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPageControllerTransitionEventArgs>(eventHandler => - { - void Handler(object sender, global::AppKit.NSPageControllerTransitionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidTransition += x, x => _data.DidTransition -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PrepareViewController => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPageControllerPrepareViewControllerEventArgs>(eventHandler => - { - void Handler(object sender, global::AppKit.NSPageControllerPrepareViewControllerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PrepareViewController += x, x => _data.PrepareViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillStartLiveTransition => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillStartLiveTransition += x, x => _data.WillStartLiveTransition -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.MacOS -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer item) => new MasterDetailPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer item) => new NavigationPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.PageRenderer item) => new PageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer item) => new TabbedPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementTrackerEvents Events(this global::Xamarin.Forms.Platform.MacOS.VisualElementTracker item) => new VisualElementTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents : global::AppKit.NSPageControllerEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.PageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageRendererEvents(global::Xamarin.Forms.Platform.MacOS.PageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementTrackerEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.VisualElementTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementTrackerEvents(global::Xamarin.Forms.Platform.MacOS.VisualElementTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NativeControlUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} - -namespace Xamarin.Forms.Platform.MacOS -{ - /// - /// Wraps delegates events from into Observables. - /// - public abstract partial class FormsApplicationDelegateRx : global::Xamarin.Forms.Platform.MacOS.FormsApplicationDelegate - { - private readonly Pharmacist.Common.SingleAwaitSubject _setupMainAppMenu = new Pharmacist.Common.SingleAwaitSubject(); - /// - /// Gets an observable which signals when the method is invoked. - /// - public global::System.IObservable SetupMainAppMenuObs => _setupMainAppMenu; - /// - public override void SetupMainAppMenu(global::AppKit.NSMenu nativeMenu) => _setupMainAppMenu.OnNext(nativeMenu); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.monoandroid81.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.monoandroid81.approved.txt deleted file mode 100644 index e69de29..0000000 diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.monoandroid90.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.monoandroid90.approved.txt deleted file mode 100644 index a52cf8b..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.monoandroid90.approved.txt +++ /dev/null @@ -1,4073 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Android.Support.V4.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DrawerLayoutEvents Events(this global::Android.Support.V4.Widget.DrawerLayout item) => new DrawerLayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NestedScrollViewEvents Events(this global::Android.Support.V4.Widget.NestedScrollView item) => new NestedScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeRefreshLayoutEvents Events(this global::Android.Support.V4.Widget.SwipeRefreshLayout item) => new SwipeRefreshLayoutEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DrawerLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.DrawerLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DrawerLayoutEvents(global::Android.Support.V4.Widget.DrawerLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerSlide => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NestedScrollViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.NestedScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NestedScrollViewEvents(global::Android.Support.V4.Widget.NestedScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeRefreshLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.SwipeRefreshLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeRefreshLayoutEvents(global::Android.Support.V4.Widget.SwipeRefreshLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refresh => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refresh += x, x => _data.Refresh -= x); - } -} - -namespace Android.Views -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewEvents Events(this global::Android.Views.View item) => new ViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewGroupEvents Events(this global::Android.Views.ViewGroup item) => new ViewGroupEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewEvents - { - private readonly global::Android.Views.View _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewEvents(global::Android.Views.View data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CapturedPointer => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CapturedPointerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ContextClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextMenuCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CreateContextMenuEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.DragEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.FocusChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GenericMotion => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.GenericMotionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Hover => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.HoverEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.KeyEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LayoutChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LongClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LongClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SystemUiVisibilityChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.SystemUiVisibilityChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Touch => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.TouchEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable UnhandledKeyEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.UnhandledKeyEventEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.UnhandledKeyEventEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.UnhandledKeyEvent += x, x => _data.UnhandledKeyEvent -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewGroupEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Views.ViewGroup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewGroupEvents(global::Android.Views.ViewGroup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationEnd => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationEndEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationRepeat => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStart => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationStartEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewAddedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); - } -} - -namespace Android.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CompoundButtonEvents Events(this global::Android.Widget.CompoundButton item) => new CompoundButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TextViewEvents Events(this global::Android.Widget.TextView item) => new TextViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CompoundButtonEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Android.Widget.CompoundButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CompoundButtonEvents(global::Android.Widget.CompoundButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.CompoundButton.CheckedChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.CompoundButton.CheckedChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChange += x, x => _data.CheckedChange -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TextViewEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Widget.TextView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TextViewEvents(global::Android.Widget.TextView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AfterTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.AfterTextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BeforeTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EditorAction => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.TextView.EditorActionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselViewEvents Events(this global::Xamarin.Forms.CarouselView item) => new CarouselViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RefreshViewEvents Events(this global::Xamarin.Forms.RefreshView item) => new RefreshViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.CarouselView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselViewEvents(global::Xamarin.Forms.CarouselView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CurrentItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PositionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RefreshViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.RefreshView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RefreshViewEvents(global::Xamarin.Forms.RefreshView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Android -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase item) => new CheckBoxRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsAppCompatActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity item) => new FormsAppCompatActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsApplicationActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsApplicationActivity item) => new FormsApplicationActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IBorderVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer item) => new IBorderVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDeviceInfoProviderEvents Events(this global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider item) => new IDeviceInfoProviderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ImageButtonRenderer item) => new ImageButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellItemRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IShellItemRenderer item) => new IShellItemRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellObservableFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.IShellObservableFragment item) => new IShellObservableFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.IShellSearchView item) => new IShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.Android.MasterDetailRenderer item) => new MasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RefreshViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.RefreshViewRenderer item) => new RefreshViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableViewHolderEvents Events(this global::Xamarin.Forms.Platform.Android.SelectableViewHolder item) => new SelectableViewHolderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellContentFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.ShellContentFragment item) => new ShellContentFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellItemRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.ShellItemRendererBase item) => new ShellItemRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSearchView item) => new ShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSectionRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSectionRenderer item) => new ShellSectionRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxRendererBaseEvents : global::Android.Widget.CompoundButtonEvents - { - private readonly global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxRendererBaseEvents(global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsAppCompatActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsAppCompatActivityEvents(global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsApplicationActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsApplicationActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsApplicationActivityEvents(global::Xamarin.Forms.Platform.Android.FormsApplicationActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IBorderVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IBorderVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDeviceInfoProviderEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDeviceInfoProviderEvents(global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ImageButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonRendererEvents(global::Xamarin.Forms.Platform.Android.ImageButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellItemRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellItemRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellItemRendererEvents(global::Xamarin.Forms.Platform.Android.IShellItemRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellObservableFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellObservableFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellObservableFragmentEvents(global::Xamarin.Forms.Platform.Android.IShellObservableFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.IShellSearchView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailRendererEvents : global::Android.Support.V4.Widget.DrawerLayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Android.MasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailRendererEvents(global::Xamarin.Forms.Platform.Android.MasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RefreshViewRendererEvents : global::Android.Support.V4.Widget.SwipeRefreshLayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Android.RefreshViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RefreshViewRendererEvents(global::Xamarin.Forms.Platform.Android.RefreshViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::Android.Support.V4.Widget.NestedScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.Android.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableViewHolderEvents - { - private readonly global::Xamarin.Forms.Platform.Android.SelectableViewHolder _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableViewHolderEvents(global::Xamarin.Forms.Platform.Android.SelectableViewHolder data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent, int>(eventHandler => - { - void Handler(object sender, int e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellContentFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellContentFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellContentFragmentEvents(global::Xamarin.Forms.Platform.Android.ShellContentFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellItemRendererBaseEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellItemRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellItemRendererBaseEvents(global::Xamarin.Forms.Platform.Android.ShellItemRendererBase data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.ShellSearchView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSectionRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSectionRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSectionRendererEvents(global::Xamarin.Forms.Platform.Android.ShellSectionRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } -} - -namespace Xamarin.Forms.Platform.Android.FastRenderers -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer item) => new ButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FrameRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer item) => new FrameRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer item) => new ImageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LabelRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer item) => new LabelRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FrameRendererEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FrameRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LabelRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LabelRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} - -namespace Xamarin.Forms.Xaml.Diagnostics -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Xaml.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Xaml.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Xaml.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::Xamarin.Forms.Xaml.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.netstandard2.0.approved.txt deleted file mode 100644 index 0e50cc2..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.netstandard2.0.approved.txt +++ /dev/null @@ -1,2743 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselViewEvents Events(this global::Xamarin.Forms.CarouselView item) => new CarouselViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RefreshViewEvents Events(this global::Xamarin.Forms.RefreshView item) => new RefreshViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.CarouselView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselViewEvents(global::Xamarin.Forms.CarouselView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CurrentItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PositionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RefreshViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.RefreshView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RefreshViewEvents(global::Xamarin.Forms.RefreshView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Xaml.Diagnostics -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Xaml.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Xaml.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Xaml.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::Xamarin.Forms.Xaml.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable VisualDiagnosticsVisualTreeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Xaml.Diagnostics.VisualTreeChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Xaml.Diagnostics.VisualTreeChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Xaml.Diagnostics.VisualDiagnostics.VisualTreeChanged += x, x => global::Xamarin.Forms.Xaml.Diagnostics.VisualDiagnostics.VisualTreeChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.tizen40.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.tizen40.approved.txt deleted file mode 100644 index e69de29..0000000 diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.uap10.0.17763.approved.txt deleted file mode 100644 index e69de29..0000000 diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.xamarinios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.xamarinios10.approved.txt deleted file mode 100644 index e69de29..0000000 diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.xamarinmac20.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991221.xamarinmac20.approved.txt deleted file mode 100644 index e69de29..0000000 diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.monoandroid81.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.monoandroid10.0.approved.txt similarity index 92% rename from src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.monoandroid81.approved.txt rename to src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.monoandroid10.0.approved.txt index 1fe6b21..d161b53 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.monoandroid81.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.monoandroid10.0.approved.txt @@ -48,9 +48,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); + }, x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -58,9 +56,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); + }, x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -68,9 +64,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); + }, x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -78,9 +72,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); + }, x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); } /// @@ -105,9 +97,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); + }, x => _data.ScrollChange += x, x => _data.ScrollChange -= x); } /// @@ -132,9 +122,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refresh += x, x => _data.Refresh -= x); + }, x => _data.Refresh += x, x => _data.Refresh -= x); } } @@ -177,9 +165,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); + }, x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -187,9 +173,7 @@ namespace Android.Views { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -197,9 +181,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); + }, x => _data.ContextClick += x, x => _data.ContextClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -207,9 +189,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); + }, x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -217,9 +197,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); + }, x => _data.Drag += x, x => _data.Drag -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -227,9 +205,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); + }, x => _data.FocusChange += x, x => _data.FocusChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -237,9 +213,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); + }, x => _data.GenericMotion += x, x => _data.GenericMotion -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -247,9 +221,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); + }, x => _data.Hover += x, x => _data.Hover -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -257,9 +229,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -267,9 +237,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); + }, x => _data.LayoutChange += x, x => _data.LayoutChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -277,9 +245,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); + }, x => _data.LongClick += x, x => _data.LongClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -287,9 +253,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); + }, x => _data.ScrollChange += x, x => _data.ScrollChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -297,9 +261,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); + }, x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -307,9 +269,15 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); + }, x => _data.Touch += x, x => _data.Touch -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UnhandledKeyEvent => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.UnhandledKeyEventEventArgs>(eventHandler => + { + void Handler(object sender, global::Android.Views.View.UnhandledKeyEventEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UnhandledKeyEvent += x, x => _data.UnhandledKeyEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -317,9 +285,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); + }, x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -327,9 +293,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); + }, x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); } /// @@ -354,9 +318,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); + }, x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -364,9 +326,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); + }, x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -374,9 +334,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); + }, x => _data.AnimationStart += x, x => _data.AnimationStart -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -384,9 +342,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); + }, x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -394,9 +350,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); + }, x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); } } @@ -439,9 +393,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.CompoundButton.CheckedChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChange += x, x => _data.CheckedChange -= x); + }, x => _data.CheckedChange += x, x => _data.CheckedChange -= x); } /// @@ -466,9 +418,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); + }, x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -476,9 +426,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); + }, x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -486,9 +434,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); + }, x => _data.EditorAction += x, x => _data.EditorAction -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -496,9 +442,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } } @@ -777,9 +721,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); + }, x => _data.ModalPopped += x, x => _data.ModalPopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -787,9 +729,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); + }, x => _data.ModalPopping += x, x => _data.ModalPopping -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -797,9 +737,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); + }, x => _data.ModalPushed += x, x => _data.ModalPushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -807,9 +745,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); + }, x => _data.ModalPushing += x, x => _data.ModalPushing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -817,9 +753,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); + }, x => _data.PageAppearing += x, x => _data.PageAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -827,9 +761,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); + }, x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); } /// @@ -854,9 +786,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -864,9 +794,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); } /// @@ -891,9 +819,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -901,9 +827,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -911,9 +835,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); + }, x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); } /// @@ -938,9 +860,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -948,9 +868,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -958,9 +876,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -985,9 +901,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -995,9 +909,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } /// @@ -1022,9 +934,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1032,9 +942,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1042,9 +950,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1052,9 +958,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -1079,9 +983,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -1106,9 +1008,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -1133,9 +1033,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -1160,9 +1058,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1187,9 +1083,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// @@ -1214,9 +1108,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); } /// @@ -1241,9 +1133,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1251,9 +1141,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -1278,9 +1166,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); + }, x => _data.ChildAdded += x, x => _data.ChildAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1288,9 +1174,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); + }, x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1298,9 +1182,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); + }, x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1308,9 +1190,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); + }, x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1319,9 +1199,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1346,9 +1224,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1356,9 +1232,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -1383,9 +1257,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1410,9 +1282,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); } /// @@ -1437,9 +1307,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1465,9 +1333,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1492,9 +1358,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1519,9 +1383,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1546,9 +1408,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1573,9 +1433,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1583,9 +1441,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1593,9 +1449,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -1620,9 +1474,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); } /// @@ -1647,9 +1499,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1657,9 +1507,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1667,9 +1515,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1677,9 +1523,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1687,9 +1531,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1714,9 +1556,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1741,9 +1581,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1768,9 +1606,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); + }, x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); } /// @@ -1795,9 +1631,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); + }, x => _data.StructureChanged += x, x => _data.StructureChanged -= x); } /// @@ -1822,9 +1656,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); + }, x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); } /// @@ -1849,9 +1681,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -1876,9 +1706,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); + }, x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1886,9 +1714,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1896,9 +1722,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1923,9 +1747,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1933,9 +1755,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); } /// @@ -1960,9 +1780,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1970,9 +1788,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1980,9 +1796,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1990,9 +1804,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } /// @@ -2017,9 +1829,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -2044,9 +1854,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); + }, x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2054,9 +1862,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); + }, x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2064,9 +1870,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2074,9 +1878,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); + }, x => _data.ItemTapped += x, x => _data.ItemTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2084,9 +1886,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2094,9 +1894,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2104,9 +1902,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2131,9 +1927,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2141,9 +1935,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); } /// @@ -2168,9 +1960,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -2195,9 +1985,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2205,9 +1993,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2215,9 +2001,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); + }, x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2225,9 +2009,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2235,9 +2017,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2245,9 +2025,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); + }, x => _data.Pushed += x, x => _data.Pushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2255,9 +2033,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2265,9 +2041,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -2292,9 +2066,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -2319,9 +2091,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2329,9 +2099,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2339,9 +2107,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -2366,9 +2132,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); + }, x => _data.PanUpdated += x, x => _data.PanUpdated -= x); } /// @@ -2393,9 +2157,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -2420,9 +2182,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); + }, x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); } /// @@ -2447,9 +2207,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); } /// @@ -2474,9 +2232,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -2501,9 +2257,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2511,9 +2265,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2538,9 +2290,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); + }, x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2548,9 +2298,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -2575,9 +2323,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2585,9 +2331,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2595,9 +2339,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2622,9 +2364,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -2649,9 +2389,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2659,9 +2397,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); } /// @@ -2686,9 +2422,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2696,9 +2430,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2706,9 +2438,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2733,9 +2463,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2760,9 +2488,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); + }, x => _data.Swiped += x, x => _data.Swiped -= x); } /// @@ -2787,9 +2513,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -2814,9 +2538,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); + }, x => _data.OnChanged += x, x => _data.OnChanged -= x); } /// @@ -2841,9 +2563,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -2868,9 +2588,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -2896,9 +2614,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); } /// @@ -2923,9 +2639,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2933,9 +2647,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); + }, x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2943,9 +2655,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2953,9 +2663,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2963,9 +2671,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2973,9 +2679,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2983,9 +2687,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -3010,9 +2712,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3020,9 +2720,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3030,9 +2728,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3040,9 +2736,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3050,9 +2744,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3060,9 +2752,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } } @@ -3113,9 +2803,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -3140,9 +2828,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); + }, x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); } /// @@ -3167,9 +2853,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3177,9 +2861,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -3204,9 +2886,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } } @@ -3317,9 +2997,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3327,9 +3005,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -3354,9 +3030,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } /// @@ -3381,9 +3055,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } /// @@ -3408,9 +3080,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3435,9 +3105,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3462,9 +3130,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } /// @@ -3489,9 +3155,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3499,9 +3163,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -3526,9 +3188,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); } /// @@ -3553,9 +3213,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); + }, x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); } /// @@ -3580,9 +3238,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); + }, x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); } /// @@ -3607,9 +3263,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3617,9 +3271,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -3644,9 +3296,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3671,9 +3321,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3681,9 +3329,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -3708,9 +3354,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3735,9 +3379,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, int e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -3762,9 +3404,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); + }, x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); } /// @@ -3789,9 +3429,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); } /// @@ -3816,9 +3454,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); + }, x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); } /// @@ -3843,9 +3479,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); + }, x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); } } @@ -3896,9 +3530,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3906,9 +3538,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -3933,9 +3563,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3943,9 +3571,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -3970,9 +3596,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3980,9 +3604,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -4007,9 +3629,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4017,9 +3637,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } } @@ -4037,8 +3655,6 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); + }, x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.monoandroid90.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.monoandroid90.approved.txt index 0ae3665..d161b53 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.monoandroid90.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.monoandroid90.approved.txt @@ -48,9 +48,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); + }, x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -58,9 +56,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); + }, x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -68,9 +64,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); + }, x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -78,9 +72,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); + }, x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); } /// @@ -105,9 +97,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); + }, x => _data.ScrollChange += x, x => _data.ScrollChange -= x); } /// @@ -132,9 +122,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refresh += x, x => _data.Refresh -= x); + }, x => _data.Refresh += x, x => _data.Refresh -= x); } } @@ -177,9 +165,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); + }, x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -187,9 +173,7 @@ namespace Android.Views { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -197,9 +181,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); + }, x => _data.ContextClick += x, x => _data.ContextClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -207,9 +189,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); + }, x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -217,9 +197,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); + }, x => _data.Drag += x, x => _data.Drag -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -227,9 +205,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); + }, x => _data.FocusChange += x, x => _data.FocusChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -237,9 +213,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); + }, x => _data.GenericMotion += x, x => _data.GenericMotion -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -247,9 +221,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); + }, x => _data.Hover += x, x => _data.Hover -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -257,9 +229,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -267,9 +237,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); + }, x => _data.LayoutChange += x, x => _data.LayoutChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -277,9 +245,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); + }, x => _data.LongClick += x, x => _data.LongClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -287,9 +253,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); + }, x => _data.ScrollChange += x, x => _data.ScrollChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -297,9 +261,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); + }, x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -307,9 +269,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); + }, x => _data.Touch += x, x => _data.Touch -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -317,9 +277,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.UnhandledKeyEventEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UnhandledKeyEvent += x, x => _data.UnhandledKeyEvent -= x); + }, x => _data.UnhandledKeyEvent += x, x => _data.UnhandledKeyEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -327,9 +285,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); + }, x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -337,9 +293,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); + }, x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); } /// @@ -364,9 +318,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); + }, x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -374,9 +326,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); + }, x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -384,9 +334,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); + }, x => _data.AnimationStart += x, x => _data.AnimationStart -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -394,9 +342,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); + }, x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -404,9 +350,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); + }, x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); } } @@ -449,9 +393,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.CompoundButton.CheckedChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChange += x, x => _data.CheckedChange -= x); + }, x => _data.CheckedChange += x, x => _data.CheckedChange -= x); } /// @@ -476,9 +418,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); + }, x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -486,9 +426,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); + }, x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -496,9 +434,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); + }, x => _data.EditorAction += x, x => _data.EditorAction -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -506,9 +442,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } } @@ -787,9 +721,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); + }, x => _data.ModalPopped += x, x => _data.ModalPopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -797,9 +729,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); + }, x => _data.ModalPopping += x, x => _data.ModalPopping -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -807,9 +737,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); + }, x => _data.ModalPushed += x, x => _data.ModalPushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -817,9 +745,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); + }, x => _data.ModalPushing += x, x => _data.ModalPushing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -827,9 +753,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); + }, x => _data.PageAppearing += x, x => _data.PageAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -837,9 +761,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); + }, x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); } /// @@ -864,9 +786,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -874,9 +794,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); } /// @@ -901,9 +819,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -911,9 +827,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -921,9 +835,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); + }, x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); } /// @@ -948,9 +860,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -958,9 +868,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -968,9 +876,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -995,9 +901,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1005,9 +909,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } /// @@ -1032,9 +934,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1042,9 +942,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1052,9 +950,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1062,9 +958,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -1089,9 +983,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -1116,9 +1008,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -1143,9 +1033,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -1170,9 +1058,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1197,9 +1083,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// @@ -1224,9 +1108,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); } /// @@ -1251,9 +1133,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1261,9 +1141,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -1288,9 +1166,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); + }, x => _data.ChildAdded += x, x => _data.ChildAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1298,9 +1174,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); + }, x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1308,9 +1182,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); + }, x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1318,9 +1190,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); + }, x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1329,9 +1199,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1356,9 +1224,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1366,9 +1232,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -1393,9 +1257,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1420,9 +1282,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); } /// @@ -1447,9 +1307,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1475,9 +1333,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1502,9 +1358,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1529,9 +1383,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1556,9 +1408,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1583,9 +1433,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1593,9 +1441,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1603,9 +1449,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -1630,9 +1474,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); } /// @@ -1657,9 +1499,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1667,9 +1507,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1677,9 +1515,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1687,9 +1523,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1697,9 +1531,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1724,9 +1556,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1751,9 +1581,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1778,9 +1606,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); + }, x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); } /// @@ -1805,9 +1631,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); + }, x => _data.StructureChanged += x, x => _data.StructureChanged -= x); } /// @@ -1832,9 +1656,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); + }, x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); } /// @@ -1859,9 +1681,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -1886,9 +1706,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); + }, x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1896,9 +1714,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1906,9 +1722,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1933,9 +1747,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1943,9 +1755,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); } /// @@ -1970,9 +1780,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1980,9 +1788,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1990,9 +1796,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2000,9 +1804,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } /// @@ -2027,9 +1829,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -2054,9 +1854,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); + }, x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2064,9 +1862,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); + }, x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2074,9 +1870,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2084,9 +1878,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); + }, x => _data.ItemTapped += x, x => _data.ItemTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2094,9 +1886,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2104,9 +1894,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2114,9 +1902,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2141,9 +1927,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2151,9 +1935,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); } /// @@ -2178,9 +1960,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -2205,9 +1985,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2215,9 +1993,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2225,9 +2001,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); + }, x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2235,9 +2009,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2245,9 +2017,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2255,9 +2025,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); + }, x => _data.Pushed += x, x => _data.Pushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2265,9 +2033,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2275,9 +2041,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -2302,9 +2066,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -2329,9 +2091,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2339,9 +2099,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2349,9 +2107,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -2376,9 +2132,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); + }, x => _data.PanUpdated += x, x => _data.PanUpdated -= x); } /// @@ -2403,9 +2157,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -2430,9 +2182,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); + }, x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); } /// @@ -2457,9 +2207,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); } /// @@ -2484,9 +2232,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -2511,9 +2257,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2521,9 +2265,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2548,9 +2290,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); + }, x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2558,9 +2298,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -2585,9 +2323,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2595,9 +2331,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2605,9 +2339,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2632,9 +2364,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -2659,9 +2389,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2669,9 +2397,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); } /// @@ -2696,9 +2422,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2706,9 +2430,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2716,9 +2438,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2743,9 +2463,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2770,9 +2488,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); + }, x => _data.Swiped += x, x => _data.Swiped -= x); } /// @@ -2797,9 +2513,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -2824,9 +2538,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); + }, x => _data.OnChanged += x, x => _data.OnChanged -= x); } /// @@ -2851,9 +2563,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -2878,9 +2588,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -2906,9 +2614,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); } /// @@ -2933,9 +2639,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2943,9 +2647,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); + }, x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2953,9 +2655,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2963,9 +2663,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2973,9 +2671,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2983,9 +2679,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2993,9 +2687,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -3020,9 +2712,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3030,9 +2720,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3040,9 +2728,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3050,9 +2736,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3060,9 +2744,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3070,9 +2752,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } } @@ -3123,9 +2803,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -3150,9 +2828,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); + }, x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); } /// @@ -3177,9 +2853,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3187,9 +2861,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -3214,9 +2886,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } } @@ -3327,9 +2997,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3337,9 +3005,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -3364,9 +3030,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } /// @@ -3391,9 +3055,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } /// @@ -3418,9 +3080,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3445,9 +3105,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3472,9 +3130,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } /// @@ -3499,9 +3155,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3509,9 +3163,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -3536,9 +3188,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); } /// @@ -3563,9 +3213,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); + }, x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); } /// @@ -3590,9 +3238,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); + }, x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); } /// @@ -3617,9 +3263,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3627,9 +3271,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -3654,9 +3296,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3681,9 +3321,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3691,9 +3329,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -3718,9 +3354,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3745,9 +3379,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, int e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -3772,9 +3404,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); + }, x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); } /// @@ -3799,9 +3429,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); } /// @@ -3826,9 +3454,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); + }, x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); } /// @@ -3853,9 +3479,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); + }, x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); } } @@ -3906,9 +3530,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3916,9 +3538,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -3943,9 +3563,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3953,9 +3571,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -3980,9 +3596,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3990,9 +3604,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -4017,9 +3629,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4027,9 +3637,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } } @@ -4047,8 +3655,6 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); + }, x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.netstandard2.0.approved.txt index 64db508..b1e631d 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.netstandard2.0.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.netstandard2.0.approved.txt @@ -280,9 +280,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); + }, x => _data.ModalPopped += x, x => _data.ModalPopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -290,9 +288,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); + }, x => _data.ModalPopping += x, x => _data.ModalPopping -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -300,9 +296,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); + }, x => _data.ModalPushed += x, x => _data.ModalPushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -310,9 +304,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); + }, x => _data.ModalPushing += x, x => _data.ModalPushing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -320,9 +312,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); + }, x => _data.PageAppearing += x, x => _data.PageAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -330,9 +320,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); + }, x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); } /// @@ -357,9 +345,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -367,9 +353,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); } /// @@ -394,9 +378,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -404,9 +386,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -414,9 +394,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); + }, x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); } /// @@ -441,9 +419,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -451,9 +427,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -461,9 +435,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -488,9 +460,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -498,9 +468,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } /// @@ -525,9 +493,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -535,9 +501,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -545,9 +509,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -555,9 +517,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -582,9 +542,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -609,9 +567,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -636,9 +592,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -663,9 +617,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -690,9 +642,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// @@ -717,9 +667,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); } /// @@ -744,9 +692,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -754,9 +700,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -781,9 +725,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); + }, x => _data.ChildAdded += x, x => _data.ChildAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -791,9 +733,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); + }, x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -801,9 +741,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); + }, x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -811,9 +749,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); + }, x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -822,9 +758,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -849,9 +783,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -859,9 +791,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -886,9 +816,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -913,9 +841,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); } /// @@ -940,9 +866,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -968,9 +892,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -995,9 +917,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1022,9 +942,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1049,9 +967,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1076,9 +992,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1086,9 +1000,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1096,9 +1008,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -1123,9 +1033,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); } /// @@ -1150,9 +1058,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1160,9 +1066,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1170,9 +1074,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1180,9 +1082,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1190,9 +1090,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1217,9 +1115,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1244,9 +1140,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1271,9 +1165,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); + }, x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); } /// @@ -1298,9 +1190,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); + }, x => _data.StructureChanged += x, x => _data.StructureChanged -= x); } /// @@ -1325,9 +1215,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); + }, x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); } /// @@ -1352,9 +1240,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -1379,9 +1265,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); + }, x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1389,9 +1273,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1399,9 +1281,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1426,9 +1306,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1436,9 +1314,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); } /// @@ -1463,9 +1339,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1473,9 +1347,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1483,9 +1355,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1493,9 +1363,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } /// @@ -1520,9 +1388,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1547,9 +1413,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); + }, x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1557,9 +1421,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); + }, x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1567,9 +1429,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1577,9 +1437,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); + }, x => _data.ItemTapped += x, x => _data.ItemTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1587,9 +1445,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1597,9 +1453,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1607,9 +1461,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1634,9 +1486,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1644,9 +1494,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); } /// @@ -1671,9 +1519,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -1698,9 +1544,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1708,9 +1552,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1718,9 +1560,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); + }, x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1728,9 +1568,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1738,9 +1576,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1748,9 +1584,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); + }, x => _data.Pushed += x, x => _data.Pushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1758,9 +1592,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1768,9 +1600,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1795,9 +1625,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1822,9 +1650,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1832,9 +1658,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1842,9 +1666,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1869,9 +1691,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); + }, x => _data.PanUpdated += x, x => _data.PanUpdated -= x); } /// @@ -1896,9 +1716,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -1923,9 +1741,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); + }, x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); } /// @@ -1950,9 +1766,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); } /// @@ -1977,9 +1791,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -2004,9 +1816,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2014,9 +1824,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2041,9 +1849,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); + }, x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2051,9 +1857,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -2078,9 +1882,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2088,9 +1890,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2098,9 +1898,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2125,9 +1923,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -2152,9 +1948,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2162,9 +1956,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); } /// @@ -2189,9 +1981,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2199,9 +1989,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2209,9 +1997,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2236,9 +2022,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2263,9 +2047,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); + }, x => _data.Swiped += x, x => _data.Swiped -= x); } /// @@ -2290,9 +2072,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -2317,9 +2097,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); + }, x => _data.OnChanged += x, x => _data.OnChanged -= x); } /// @@ -2344,9 +2122,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -2371,9 +2147,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -2399,9 +2173,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); } /// @@ -2426,9 +2198,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2436,9 +2206,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); + }, x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2446,9 +2214,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2456,9 +2222,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2466,9 +2230,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2476,9 +2238,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2486,9 +2246,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2513,9 +2271,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2523,9 +2279,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2533,9 +2287,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2543,9 +2295,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2553,9 +2303,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2563,9 +2311,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } } @@ -2616,9 +2362,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -2643,9 +2387,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); + }, x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); } /// @@ -2670,9 +2412,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2680,9 +2420,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -2707,8 +2445,6 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.tizen40.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.tizen40.approved.txt index 46c224c..da9ce96 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.tizen40.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.tizen40.approved.txt @@ -56,9 +56,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -66,9 +64,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChangedByUser += x, x => _data.ChangedByUser -= x); + }, x => _data.ChangedByUser += x, x => _data.ChangedByUser -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -76,9 +72,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -86,9 +80,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); } /// @@ -113,9 +105,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -123,9 +113,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Deleted += x, x => _data.Deleted -= x); + }, x => _data.Deleted += x, x => _data.Deleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -133,9 +121,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -143,9 +129,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -153,9 +137,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MoreButtonPressed += x, x => _data.MoreButtonPressed -= x); + }, x => _data.MoreButtonPressed += x, x => _data.MoreButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -163,9 +145,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Moved += x, x => _data.Moved -= x); + }, x => _data.Moved += x, x => _data.Moved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -173,9 +153,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RenderPost += x, x => _data.RenderPost -= x); + }, x => _data.RenderPost += x, x => _data.RenderPost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -183,9 +161,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resized += x, x => _data.Resized -= x); + }, x => _data.Resized += x, x => _data.Resized -= x); } /// @@ -210,9 +186,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); + }, x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -220,9 +194,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ThemeChanged += x, x => _data.ThemeChanged -= x); + }, x => _data.ThemeChanged += x, x => _data.ThemeChanged -= x); } /// @@ -247,9 +219,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -257,9 +227,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OutsideClicked += x, x => _data.OutsideClicked -= x); + }, x => _data.OutsideClicked += x, x => _data.OutsideClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -267,9 +235,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ShowAnimationFinished += x, x => _data.ShowAnimationFinished -= x); + }, x => _data.ShowAnimationFinished += x, x => _data.ShowAnimationFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -277,9 +243,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TimedOut += x, x => _data.TimedOut -= x); + }, x => _data.TimedOut += x, x => _data.TimedOut -= x); } /// @@ -304,9 +268,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -314,9 +276,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } } @@ -595,9 +555,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); + }, x => _data.ModalPopped += x, x => _data.ModalPopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -605,9 +563,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); + }, x => _data.ModalPopping += x, x => _data.ModalPopping -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -615,9 +571,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); + }, x => _data.ModalPushed += x, x => _data.ModalPushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -625,9 +579,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); + }, x => _data.ModalPushing += x, x => _data.ModalPushing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -635,9 +587,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); + }, x => _data.PageAppearing += x, x => _data.PageAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -645,9 +595,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); + }, x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); } /// @@ -672,9 +620,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -682,9 +628,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); } /// @@ -709,9 +653,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -719,9 +661,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -729,9 +669,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); + }, x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); } /// @@ -756,9 +694,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -766,9 +702,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -776,9 +710,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -803,9 +735,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -813,9 +743,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } /// @@ -840,9 +768,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -850,9 +776,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -860,9 +784,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -870,9 +792,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -897,9 +817,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -924,9 +842,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -951,9 +867,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -978,9 +892,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1005,9 +917,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// @@ -1032,9 +942,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); } /// @@ -1059,9 +967,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1069,9 +975,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -1096,9 +1000,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); + }, x => _data.ChildAdded += x, x => _data.ChildAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1106,9 +1008,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); + }, x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1116,9 +1016,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); + }, x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1126,9 +1024,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); + }, x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1137,9 +1033,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1164,9 +1058,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1174,9 +1066,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -1201,9 +1091,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1228,9 +1116,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); } /// @@ -1255,9 +1141,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1283,9 +1167,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1310,9 +1192,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1337,9 +1217,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1364,9 +1242,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1391,9 +1267,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1401,9 +1275,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1411,9 +1283,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -1438,9 +1308,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); } /// @@ -1465,9 +1333,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1475,9 +1341,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1485,9 +1349,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1495,9 +1357,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1505,9 +1365,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1532,9 +1390,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1559,9 +1415,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1586,9 +1440,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); + }, x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); } /// @@ -1613,9 +1465,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); + }, x => _data.StructureChanged += x, x => _data.StructureChanged -= x); } /// @@ -1640,9 +1490,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); + }, x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); } /// @@ -1667,9 +1515,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -1694,9 +1540,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); + }, x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1704,9 +1548,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1714,9 +1556,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1741,9 +1581,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1751,9 +1589,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); } /// @@ -1778,9 +1614,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1788,9 +1622,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1798,9 +1630,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1808,9 +1638,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } /// @@ -1835,9 +1663,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1862,9 +1688,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); + }, x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1872,9 +1696,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); + }, x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1882,9 +1704,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1892,9 +1712,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); + }, x => _data.ItemTapped += x, x => _data.ItemTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1902,9 +1720,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1912,9 +1728,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1922,9 +1736,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1949,9 +1761,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1959,9 +1769,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); } /// @@ -1986,9 +1794,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -2013,9 +1819,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2023,9 +1827,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2033,9 +1835,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); + }, x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2043,9 +1843,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2053,9 +1851,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2063,9 +1859,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); + }, x => _data.Pushed += x, x => _data.Pushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2073,9 +1867,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2083,9 +1875,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -2110,9 +1900,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -2137,9 +1925,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2147,9 +1933,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2157,9 +1941,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -2184,9 +1966,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); + }, x => _data.PanUpdated += x, x => _data.PanUpdated -= x); } /// @@ -2211,9 +1991,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -2238,9 +2016,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); + }, x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); } /// @@ -2265,9 +2041,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); } /// @@ -2292,9 +2066,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -2319,9 +2091,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2329,9 +2099,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2356,9 +2124,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); + }, x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2366,9 +2132,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -2393,9 +2157,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2403,9 +2165,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2413,9 +2173,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2440,9 +2198,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -2467,9 +2223,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2477,9 +2231,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); } /// @@ -2504,9 +2256,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2514,9 +2264,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2524,9 +2272,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2551,9 +2297,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2578,9 +2322,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); + }, x => _data.Swiped += x, x => _data.Swiped -= x); } /// @@ -2605,9 +2347,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -2632,9 +2372,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); + }, x => _data.OnChanged += x, x => _data.OnChanged -= x); } /// @@ -2659,9 +2397,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -2686,9 +2422,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -2714,9 +2448,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); } /// @@ -2741,9 +2473,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2751,9 +2481,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); + }, x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2761,9 +2489,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2771,9 +2497,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2781,9 +2505,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2791,9 +2513,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2801,9 +2521,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2828,9 +2546,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2838,9 +2554,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2848,9 +2562,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2858,9 +2570,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2868,9 +2578,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2878,9 +2586,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } } @@ -2931,9 +2637,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -2958,9 +2662,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); + }, x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); } /// @@ -2985,9 +2687,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2995,9 +2695,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -3022,9 +2720,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } } @@ -3095,9 +2791,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); + }, x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); } /// @@ -3122,9 +2816,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -3149,9 +2841,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -3176,9 +2866,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); } /// @@ -3203,9 +2891,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::ElmSharp.ToolbarItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } /// @@ -3230,9 +2916,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); + }, x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); } /// @@ -3257,9 +2941,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); + }, x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); } /// @@ -3284,9 +2966,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -3311,9 +2991,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); } } @@ -3392,9 +3070,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); } /// @@ -3419,9 +3095,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); + }, x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); } /// @@ -3446,9 +3120,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Shown += x, x => _data.Shown -= x); + }, x => _data.Shown += x, x => _data.Shown -= x); } /// @@ -3473,9 +3145,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextBlockFocused += x, x => _data.TextBlockFocused -= x); + }, x => _data.TextBlockFocused += x, x => _data.TextBlockFocused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3483,9 +3153,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextBlockUnfocused += x, x => _data.TextBlockUnfocused -= x); + }, x => _data.TextBlockUnfocused += x, x => _data.TextBlockUnfocused -= x); } /// @@ -3510,9 +3178,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -3537,9 +3203,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); + }, x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); } /// @@ -3564,9 +3228,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -3591,9 +3253,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -3618,9 +3278,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.IsPresentedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3628,9 +3286,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.UpdateIsPresentChangeableEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UpdateIsPresentChangeable += x, x => _data.UpdateIsPresentChangeable -= x); + }, x => _data.UpdateIsPresentChangeable += x, x => _data.UpdateIsPresentChangeable -= x); } /// @@ -3655,9 +3311,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); } /// @@ -3682,9 +3336,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RequestSelected += x, x => _data.RequestSelected -= x); + }, x => _data.RequestSelected += x, x => _data.RequestSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3692,9 +3344,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } } @@ -3733,9 +3383,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native.Watch { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); + }, x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); } } @@ -3753,8 +3401,6 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); + }, x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.uap10.0.17763.approved.txt index d79be4b..5d307cf 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.uap10.0.17763.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.uap10.0.17763.approved.txt @@ -280,9 +280,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); + }, x => _data.ModalPopped += x, x => _data.ModalPopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -290,9 +288,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); + }, x => _data.ModalPopping += x, x => _data.ModalPopping -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -300,9 +296,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); + }, x => _data.ModalPushed += x, x => _data.ModalPushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -310,9 +304,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); + }, x => _data.ModalPushing += x, x => _data.ModalPushing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -320,9 +312,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); + }, x => _data.PageAppearing += x, x => _data.PageAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -330,9 +320,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); + }, x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); } /// @@ -357,9 +345,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -367,9 +353,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); } /// @@ -394,9 +378,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -404,9 +386,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -414,9 +394,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); + }, x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); } /// @@ -441,9 +419,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -451,9 +427,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -461,9 +435,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -488,9 +460,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -498,9 +468,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } /// @@ -525,9 +493,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -535,9 +501,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -545,9 +509,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -555,9 +517,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -582,9 +542,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -609,9 +567,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -636,9 +592,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -663,9 +617,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -690,9 +642,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// @@ -717,9 +667,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); } /// @@ -744,9 +692,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -754,9 +700,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -781,9 +725,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); + }, x => _data.ChildAdded += x, x => _data.ChildAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -791,9 +733,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); + }, x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -801,9 +741,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); + }, x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -811,9 +749,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); + }, x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -822,9 +758,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -849,9 +783,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -859,9 +791,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -886,9 +816,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -913,9 +841,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); } /// @@ -940,9 +866,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -968,9 +892,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -995,9 +917,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1022,9 +942,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1049,9 +967,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1076,9 +992,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1086,9 +1000,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1096,9 +1008,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -1123,9 +1033,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); } /// @@ -1150,9 +1058,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1160,9 +1066,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1170,9 +1074,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1180,9 +1082,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1190,9 +1090,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1217,9 +1115,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1244,9 +1140,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1271,9 +1165,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); + }, x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); } /// @@ -1298,9 +1190,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); + }, x => _data.StructureChanged += x, x => _data.StructureChanged -= x); } /// @@ -1325,9 +1215,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); + }, x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); } /// @@ -1352,9 +1240,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -1379,9 +1265,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); + }, x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1389,9 +1273,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1399,9 +1281,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1426,9 +1306,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1436,9 +1314,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); } /// @@ -1463,9 +1339,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1473,9 +1347,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1483,9 +1355,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1493,9 +1363,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } /// @@ -1520,9 +1388,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1547,9 +1413,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); + }, x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1557,9 +1421,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); + }, x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1567,9 +1429,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1577,9 +1437,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); + }, x => _data.ItemTapped += x, x => _data.ItemTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1587,9 +1445,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1597,9 +1453,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1607,9 +1461,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1634,9 +1486,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1644,9 +1494,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); } /// @@ -1671,9 +1519,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -1698,9 +1544,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1708,9 +1552,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1718,9 +1560,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); + }, x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1728,9 +1568,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1738,9 +1576,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1748,9 +1584,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); + }, x => _data.Pushed += x, x => _data.Pushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1758,9 +1592,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1768,9 +1600,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1795,9 +1625,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1822,9 +1650,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1832,9 +1658,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1842,9 +1666,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1869,9 +1691,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); + }, x => _data.PanUpdated += x, x => _data.PanUpdated -= x); } /// @@ -1896,9 +1716,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -1923,9 +1741,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); + }, x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); } /// @@ -1950,9 +1766,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); } /// @@ -1977,9 +1791,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -2004,9 +1816,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2014,9 +1824,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2041,9 +1849,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); + }, x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2051,9 +1857,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -2078,9 +1882,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2088,9 +1890,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2098,9 +1898,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2125,9 +1923,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -2152,9 +1948,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2162,9 +1956,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); } /// @@ -2189,9 +1981,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2199,9 +1989,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2209,9 +1997,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2236,9 +2022,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2263,9 +2047,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); + }, x => _data.Swiped += x, x => _data.Swiped -= x); } /// @@ -2290,9 +2072,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -2317,9 +2097,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); + }, x => _data.OnChanged += x, x => _data.OnChanged -= x); } /// @@ -2344,9 +2122,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -2371,9 +2147,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -2399,9 +2173,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); } /// @@ -2426,9 +2198,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2436,9 +2206,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); + }, x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2446,9 +2214,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2456,9 +2222,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2466,9 +2230,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2476,9 +2238,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2486,9 +2246,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2513,9 +2271,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2523,9 +2279,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2533,9 +2287,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2543,9 +2295,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2553,9 +2303,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2563,9 +2311,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } } @@ -2616,9 +2362,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -2643,9 +2387,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); + }, x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); } /// @@ -2670,9 +2412,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2680,9 +2420,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -2707,9 +2445,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } } @@ -2780,9 +2516,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -2807,9 +2541,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// @@ -2834,9 +2566,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OptionSelected += x, x => _data.OptionSelected -= x); + }, x => _data.OptionSelected += x, x => _data.OptionSelected -= x); } /// @@ -2861,9 +2591,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -2888,9 +2616,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); + }, x => _data.ControlChanged += x, x => _data.ControlChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2898,9 +2624,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); + }, x => _data.ControlChanging += x, x => _data.ControlChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2908,9 +2632,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -2935,9 +2657,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -2962,9 +2682,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -2989,9 +2707,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -3016,9 +2732,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } } @@ -3057,8 +2771,6 @@ namespace Xamarin.Forms.Platform.WinRT { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.xamarinios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.xamarinios10.approved.txt index c6139d5..76677d7 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.xamarinios10.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.xamarinios10.approved.txt @@ -52,9 +52,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DecelerationEnded += x, x => _data.DecelerationEnded -= x); + }, x => _data.DecelerationEnded += x, x => _data.DecelerationEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -62,9 +60,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DecelerationStarted += x, x => _data.DecelerationStarted -= x); + }, x => _data.DecelerationStarted += x, x => _data.DecelerationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -72,9 +68,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DidChangeAdjustedContentInset += x, x => _data.DidChangeAdjustedContentInset -= x); + }, x => _data.DidChangeAdjustedContentInset += x, x => _data.DidChangeAdjustedContentInset -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -82,9 +76,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DidZoom += x, x => _data.DidZoom -= x); + }, x => _data.DidZoom += x, x => _data.DidZoom -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -92,9 +84,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.DraggingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DraggingEnded += x, x => _data.DraggingEnded -= x); + }, x => _data.DraggingEnded += x, x => _data.DraggingEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -102,9 +92,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DraggingStarted += x, x => _data.DraggingStarted -= x); + }, x => _data.DraggingStarted += x, x => _data.DraggingStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -112,9 +100,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollAnimationEnded += x, x => _data.ScrollAnimationEnded -= x); + }, x => _data.ScrollAnimationEnded += x, x => _data.ScrollAnimationEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -122,9 +108,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -132,9 +116,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrolledToTop += x, x => _data.ScrolledToTop -= x); + }, x => _data.ScrolledToTop += x, x => _data.ScrolledToTop -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -142,9 +124,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.WillEndDraggingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillEndDragging += x, x => _data.WillEndDragging -= x); + }, x => _data.WillEndDragging += x, x => _data.WillEndDragging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -152,9 +132,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.ZoomingEndedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ZoomingEnded += x, x => _data.ZoomingEnded -= x); + }, x => _data.ZoomingEnded += x, x => _data.ZoomingEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -162,9 +140,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UIScrollViewZoomingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ZoomingStarted += x, x => _data.ZoomingStarted -= x); + }, x => _data.ZoomingStarted += x, x => _data.ZoomingStarted -= x); } /// @@ -189,9 +165,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DidCollapse += x, x => _data.DidCollapse -= x); + }, x => _data.DidCollapse += x, x => _data.DidCollapse -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -199,9 +173,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DidExpand += x, x => _data.DidExpand -= x); + }, x => _data.DidExpand += x, x => _data.DidExpand -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -209,9 +181,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InteractivePresentationGestureDidEnd += x, x => _data.InteractivePresentationGestureDidEnd -= x); + }, x => _data.InteractivePresentationGestureDidEnd += x, x => _data.InteractivePresentationGestureDidEnd -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -219,9 +189,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InteractivePresentationGestureWillBegin += x, x => _data.InteractivePresentationGestureWillBegin -= x); + }, x => _data.InteractivePresentationGestureWillBegin += x, x => _data.InteractivePresentationGestureWillBegin -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -229,9 +197,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UISplitViewControllerDisplayModeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillChangeDisplayMode += x, x => _data.WillChangeDisplayMode -= x); + }, x => _data.WillChangeDisplayMode += x, x => _data.WillChangeDisplayMode -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -239,9 +205,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UISplitViewControllerWillShowHideColumnEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillHideColumn += x, x => _data.WillHideColumn -= x); + }, x => _data.WillHideColumn += x, x => _data.WillHideColumn -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -249,9 +213,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UISplitViewHideEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillHideViewController += x, x => _data.WillHideViewController -= x); + }, x => _data.WillHideViewController += x, x => _data.WillHideViewController -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -259,9 +221,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UISplitViewPresentEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillPresentViewController += x, x => _data.WillPresentViewController -= x); + }, x => _data.WillPresentViewController += x, x => _data.WillPresentViewController -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -269,9 +229,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UISplitViewControllerWillShowHideColumnEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillShowColumn += x, x => _data.WillShowColumn -= x); + }, x => _data.WillShowColumn += x, x => _data.WillShowColumn -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -279,9 +237,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UISplitViewShowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillShowViewController += x, x => _data.WillShowViewController -= x); + }, x => _data.WillShowViewController += x, x => _data.WillShowViewController -= x); } /// @@ -306,9 +262,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FinishedCustomizingViewControllers += x, x => _data.FinishedCustomizingViewControllers -= x); + }, x => _data.FinishedCustomizingViewControllers += x, x => _data.FinishedCustomizingViewControllers -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -316,9 +270,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UITabBarCustomizeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnCustomizingViewControllers += x, x => _data.OnCustomizingViewControllers -= x); + }, x => _data.OnCustomizingViewControllers += x, x => _data.OnCustomizingViewControllers -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -326,9 +278,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnEndCustomizingViewControllers += x, x => _data.OnEndCustomizingViewControllers -= x); + }, x => _data.OnEndCustomizingViewControllers += x, x => _data.OnEndCustomizingViewControllers -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -336,9 +286,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UITabBarSelectionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewControllerSelected += x, x => _data.ViewControllerSelected -= x); + }, x => _data.ViewControllerSelected += x, x => _data.ViewControllerSelected -= x); } /// @@ -363,9 +311,7 @@ namespace UIKit { void Handler(object sender, global::UIKit.UIWebErrorArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadError += x, x => _data.LoadError -= x); + }, x => _data.LoadError += x, x => _data.LoadError -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -373,9 +319,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadFinished += x, x => _data.LoadFinished -= x); + }, x => _data.LoadFinished += x, x => _data.LoadFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -383,9 +327,7 @@ namespace UIKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LoadStarted += x, x => _data.LoadStarted -= x); + }, x => _data.LoadStarted += x, x => _data.LoadStarted -= x); } } @@ -664,9 +606,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); + }, x => _data.ModalPopped += x, x => _data.ModalPopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -674,9 +614,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); + }, x => _data.ModalPopping += x, x => _data.ModalPopping -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -684,9 +622,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); + }, x => _data.ModalPushed += x, x => _data.ModalPushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -694,9 +630,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); + }, x => _data.ModalPushing += x, x => _data.ModalPushing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -704,9 +638,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); + }, x => _data.PageAppearing += x, x => _data.PageAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -714,9 +646,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); + }, x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); } /// @@ -741,9 +671,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -751,9 +679,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); } /// @@ -778,9 +704,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -788,9 +712,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -798,9 +720,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); + }, x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); } /// @@ -825,9 +745,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -835,9 +753,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -845,9 +761,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -872,9 +786,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -882,9 +794,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } /// @@ -909,9 +819,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -919,9 +827,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -929,9 +835,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -939,9 +843,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -966,9 +868,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -993,9 +893,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -1020,9 +918,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -1047,9 +943,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1074,9 +968,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// @@ -1101,9 +993,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); } /// @@ -1128,9 +1018,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1138,9 +1026,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -1165,9 +1051,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); + }, x => _data.ChildAdded += x, x => _data.ChildAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1175,9 +1059,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); + }, x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1185,9 +1067,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); + }, x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1195,9 +1075,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); + }, x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1206,9 +1084,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1233,9 +1109,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1243,9 +1117,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -1270,9 +1142,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1297,9 +1167,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); } /// @@ -1324,9 +1192,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1352,9 +1218,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1379,9 +1243,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1406,9 +1268,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1433,9 +1293,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1460,9 +1318,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1470,9 +1326,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1480,9 +1334,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -1507,9 +1359,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); } /// @@ -1534,9 +1384,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1544,9 +1392,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1554,9 +1400,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1564,9 +1408,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1574,9 +1416,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1601,9 +1441,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1628,9 +1466,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1655,9 +1491,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); + }, x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); } /// @@ -1682,9 +1516,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); + }, x => _data.StructureChanged += x, x => _data.StructureChanged -= x); } /// @@ -1709,9 +1541,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); + }, x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); } /// @@ -1736,9 +1566,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -1763,9 +1591,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); + }, x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1773,9 +1599,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1783,9 +1607,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1810,9 +1632,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1820,9 +1640,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); } /// @@ -1847,9 +1665,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1857,9 +1673,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1867,9 +1681,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1877,9 +1689,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } /// @@ -1904,9 +1714,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1931,9 +1739,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); + }, x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1941,9 +1747,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); + }, x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1951,9 +1755,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1961,9 +1763,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); + }, x => _data.ItemTapped += x, x => _data.ItemTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1971,9 +1771,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1981,9 +1779,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1991,9 +1787,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2018,9 +1812,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2028,9 +1820,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); } /// @@ -2055,9 +1845,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -2082,9 +1870,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2092,9 +1878,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2102,9 +1886,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); + }, x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2112,9 +1894,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2122,9 +1902,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2132,9 +1910,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); + }, x => _data.Pushed += x, x => _data.Pushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2142,9 +1918,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2152,9 +1926,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -2179,9 +1951,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -2206,9 +1976,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2216,9 +1984,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2226,9 +1992,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -2253,9 +2017,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); + }, x => _data.PanUpdated += x, x => _data.PanUpdated -= x); } /// @@ -2280,9 +2042,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -2307,9 +2067,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); + }, x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); } /// @@ -2334,9 +2092,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); } /// @@ -2361,9 +2117,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -2388,9 +2142,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2398,9 +2150,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2425,9 +2175,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); + }, x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2435,9 +2183,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -2462,9 +2208,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2472,9 +2216,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2482,9 +2224,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2509,9 +2249,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -2536,9 +2274,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2546,9 +2282,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); } /// @@ -2573,9 +2307,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2583,9 +2315,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2593,9 +2323,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2620,9 +2348,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2647,9 +2373,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); + }, x => _data.Swiped += x, x => _data.Swiped -= x); } /// @@ -2674,9 +2398,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -2701,9 +2423,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); + }, x => _data.OnChanged += x, x => _data.OnChanged -= x); } /// @@ -2728,9 +2448,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -2755,9 +2473,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -2783,9 +2499,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); } /// @@ -2810,9 +2524,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2820,9 +2532,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); + }, x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2830,9 +2540,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2840,9 +2548,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2850,9 +2556,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2860,9 +2564,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2870,9 +2572,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2897,9 +2597,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2907,9 +2605,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2917,9 +2613,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2927,9 +2621,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2937,9 +2629,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2947,9 +2637,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } } @@ -3000,9 +2688,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -3027,9 +2713,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); + }, x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); } /// @@ -3054,9 +2738,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3064,9 +2746,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -3091,9 +2771,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } } @@ -3212,9 +2890,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3239,9 +2915,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::Xamarin.Forms.Platform.iOS.ElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3266,9 +2940,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillAppear += x, x => _data.WillAppear -= x); + }, x => _data.WillAppear += x, x => _data.WillAppear -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3276,9 +2948,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); + }, x => _data.WillDisappear += x, x => _data.WillDisappear -= x); } /// @@ -3303,9 +2973,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -3330,9 +2998,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3357,9 +3023,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); + }, x => _data.ControlChanged += x, x => _data.ControlChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3367,9 +3031,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); + }, x => _data.ControlChanging += x, x => _data.ControlChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3377,9 +3039,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -3404,9 +3064,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DidAppear += x, x => _data.DidAppear -= x); + }, x => _data.DidAppear += x, x => _data.DidAppear -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3414,9 +3072,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); + }, x => _data.WillDisappear += x, x => _data.WillDisappear -= x); } /// @@ -3441,9 +3097,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3468,9 +3122,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3495,9 +3147,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3522,9 +3172,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3549,9 +3197,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillAppear += x, x => _data.WillAppear -= x); + }, x => _data.WillAppear += x, x => _data.WillAppear -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3559,9 +3205,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); + }, x => _data.WillDisappear += x, x => _data.WillDisappear -= x); } /// @@ -3586,9 +3230,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3613,9 +3255,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, object e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -3640,9 +3280,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::UIKit.UIScrollView e) => eventHandler(e); return Handler; - } - - , x => _data.ScrolledEvent += x, x => _data.ScrolledEvent -= x); + }, x => _data.ScrolledEvent += x, x => _data.ScrolledEvent -= x); } /// @@ -3667,9 +3305,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3694,9 +3330,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3721,9 +3355,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContentSizeChanged += x, x => _data.ContentSizeChanged -= x); + }, x => _data.ContentSizeChanged += x, x => _data.ContentSizeChanged -= x); } /// @@ -3748,9 +3380,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); + }, x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); } /// @@ -3775,9 +3405,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3802,9 +3430,7 @@ namespace Xamarin.Forms.Platform.iOS { void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } } @@ -3822,8 +3448,6 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); + }, x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); } -} +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.xamarinmac20.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.xamarinmac20.approved.txt index 776ac6c..908a7d1 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.xamarinmac20.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.3.0.991250.xamarinmac20.approved.txt @@ -40,9 +40,7 @@ namespace AppKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DidEndLiveTransition += x, x => _data.DidEndLiveTransition -= x); + }, x => _data.DidEndLiveTransition += x, x => _data.DidEndLiveTransition -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -50,9 +48,7 @@ namespace AppKit { void Handler(object sender, global::AppKit.NSPageControllerTransitionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DidTransition += x, x => _data.DidTransition -= x); + }, x => _data.DidTransition += x, x => _data.DidTransition -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -60,9 +56,7 @@ namespace AppKit { void Handler(object sender, global::AppKit.NSPageControllerPrepareViewControllerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PrepareViewController += x, x => _data.PrepareViewController -= x); + }, x => _data.PrepareViewController += x, x => _data.PrepareViewController -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -70,9 +64,7 @@ namespace AppKit { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WillStartLiveTransition += x, x => _data.WillStartLiveTransition -= x); + }, x => _data.WillStartLiveTransition += x, x => _data.WillStartLiveTransition -= x); } } @@ -351,9 +343,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); + }, x => _data.ModalPopped += x, x => _data.ModalPopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -361,9 +351,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); + }, x => _data.ModalPopping += x, x => _data.ModalPopping -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -371,9 +359,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); + }, x => _data.ModalPushed += x, x => _data.ModalPushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -381,9 +367,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); + }, x => _data.ModalPushing += x, x => _data.ModalPushing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -391,9 +375,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); + }, x => _data.PageAppearing += x, x => _data.PageAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -401,9 +383,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); + }, x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); } /// @@ -428,9 +408,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -438,9 +416,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); } /// @@ -465,9 +441,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -475,9 +449,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -485,9 +457,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); + }, x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); } /// @@ -512,9 +482,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -522,9 +490,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -532,9 +498,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -559,9 +523,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -569,9 +531,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } /// @@ -596,9 +556,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -606,9 +564,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -616,9 +572,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -626,9 +580,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -653,9 +605,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -680,9 +630,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -707,9 +655,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -734,9 +680,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -761,9 +705,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// @@ -788,9 +730,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); } /// @@ -815,9 +755,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -825,9 +763,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -852,9 +788,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); + }, x => _data.ChildAdded += x, x => _data.ChildAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -862,9 +796,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); + }, x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -872,9 +804,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); + }, x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -882,9 +812,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); + }, x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -893,9 +821,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -920,9 +846,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -930,9 +854,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -957,9 +879,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -984,9 +904,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); } /// @@ -1011,9 +929,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1039,9 +955,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1066,9 +980,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1093,9 +1005,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1120,9 +1030,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1147,9 +1055,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1157,9 +1063,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1167,9 +1071,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -1194,9 +1096,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); } /// @@ -1221,9 +1121,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1231,9 +1129,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1241,9 +1137,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1251,9 +1145,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1261,9 +1153,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1288,9 +1178,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1315,9 +1203,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1342,9 +1228,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); + }, x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); } /// @@ -1369,9 +1253,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); + }, x => _data.StructureChanged += x, x => _data.StructureChanged -= x); } /// @@ -1396,9 +1278,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); + }, x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); } /// @@ -1423,9 +1303,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -1450,9 +1328,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); + }, x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1460,9 +1336,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1470,9 +1344,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1497,9 +1369,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1507,9 +1377,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); } /// @@ -1534,9 +1402,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1544,9 +1410,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1554,9 +1418,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1564,9 +1426,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } /// @@ -1591,9 +1451,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1618,9 +1476,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); + }, x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1628,9 +1484,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); + }, x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1638,9 +1492,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1648,9 +1500,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); + }, x => _data.ItemTapped += x, x => _data.ItemTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1658,9 +1508,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1668,9 +1516,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1678,9 +1524,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1705,9 +1549,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1715,9 +1557,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); } /// @@ -1742,9 +1582,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -1769,9 +1607,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1779,9 +1615,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1789,9 +1623,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); + }, x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1799,9 +1631,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1809,9 +1639,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1819,9 +1647,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); + }, x => _data.Pushed += x, x => _data.Pushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1829,9 +1655,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1839,9 +1663,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1866,9 +1688,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1893,9 +1713,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1903,9 +1721,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1913,9 +1729,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1940,9 +1754,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); + }, x => _data.PanUpdated += x, x => _data.PanUpdated -= x); } /// @@ -1967,9 +1779,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -1994,9 +1804,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); + }, x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); } /// @@ -2021,9 +1829,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); } /// @@ -2048,9 +1854,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -2075,9 +1879,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2085,9 +1887,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2112,9 +1912,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); + }, x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2122,9 +1920,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -2149,9 +1945,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2159,9 +1953,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2169,9 +1961,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2196,9 +1986,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -2223,9 +2011,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2233,9 +2019,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); } /// @@ -2260,9 +2044,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2270,9 +2052,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2280,9 +2060,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2307,9 +2085,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2334,9 +2110,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); + }, x => _data.Swiped += x, x => _data.Swiped -= x); } /// @@ -2361,9 +2135,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -2388,9 +2160,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); + }, x => _data.OnChanged += x, x => _data.OnChanged -= x); } /// @@ -2415,9 +2185,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -2442,9 +2210,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -2470,9 +2236,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); } /// @@ -2497,9 +2261,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2507,9 +2269,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); + }, x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2517,9 +2277,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2527,9 +2285,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2537,9 +2293,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2547,9 +2301,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2557,9 +2309,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2584,9 +2334,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2594,9 +2342,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2604,9 +2350,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2614,9 +2358,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2624,9 +2366,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2634,9 +2374,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } } @@ -2687,9 +2425,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -2714,9 +2450,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); + }, x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); } /// @@ -2741,9 +2475,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2751,9 +2483,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -2778,9 +2508,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } } @@ -2851,9 +2579,7 @@ namespace Xamarin.Forms.Platform.MacOS { void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -2878,9 +2604,7 @@ namespace Xamarin.Forms.Platform.MacOS { void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -2905,9 +2629,7 @@ namespace Xamarin.Forms.Platform.MacOS { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); + }, x => _data.ControlChanged += x, x => _data.ControlChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2915,9 +2637,7 @@ namespace Xamarin.Forms.Platform.MacOS { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); + }, x => _data.ControlChanging += x, x => _data.ControlChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2925,9 +2645,7 @@ namespace Xamarin.Forms.Platform.MacOS { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -2952,9 +2670,7 @@ namespace Xamarin.Forms.Platform.MacOS { void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -2979,9 +2695,7 @@ namespace Xamarin.Forms.Platform.MacOS { void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3006,9 +2720,7 @@ namespace Xamarin.Forms.Platform.MacOS { void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3033,9 +2745,7 @@ namespace Xamarin.Forms.Platform.MacOS { void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3060,9 +2770,7 @@ namespace Xamarin.Forms.Platform.MacOS { void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3087,9 +2795,7 @@ namespace Xamarin.Forms.Platform.MacOS { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); + }, x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); } } @@ -3107,9 +2813,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); + }, x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); } } diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.monoandroid81.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.monoandroid81.approved.txt deleted file mode 100644 index 46a6938..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.monoandroid81.approved.txt +++ /dev/null @@ -1,4352 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Android.Support.V4.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DrawerLayoutEvents Events(this global::Android.Support.V4.Widget.DrawerLayout item) => new DrawerLayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NestedScrollViewEvents Events(this global::Android.Support.V4.Widget.NestedScrollView item) => new NestedScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeRefreshLayoutEvents Events(this global::Android.Support.V4.Widget.SwipeRefreshLayout item) => new SwipeRefreshLayoutEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DrawerLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.DrawerLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DrawerLayoutEvents(global::Android.Support.V4.Widget.DrawerLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerSlide => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NestedScrollViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.NestedScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NestedScrollViewEvents(global::Android.Support.V4.Widget.NestedScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeRefreshLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.SwipeRefreshLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeRefreshLayoutEvents(global::Android.Support.V4.Widget.SwipeRefreshLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refresh => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refresh += x, x => _data.Refresh -= x); - } -} - -namespace Android.Views -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewEvents Events(this global::Android.Views.View item) => new ViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewGroupEvents Events(this global::Android.Views.ViewGroup item) => new ViewGroupEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewEvents - { - private readonly global::Android.Views.View _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewEvents(global::Android.Views.View data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CapturedPointer => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CapturedPointerEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Click => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ContextClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContextMenuCreated => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.CreateContextMenuEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Drag => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.DragEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.FocusChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GenericMotion => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.GenericMotionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Hover => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.HoverEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyPress => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.KeyEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LayoutChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LongClick => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.LongClickEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SystemUiVisibilityChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.SystemUiVisibilityChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Touch => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.TouchEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewAttachedToWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewAttachedToWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewDetachedFromWindow => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.View.ViewDetachedFromWindowEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewGroupEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Views.ViewGroup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewGroupEvents(global::Android.Views.ViewGroup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationEnd => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationEndEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationRepeat => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStart => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.Animations.Animation.AnimationStartEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewAddedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildViewRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); - } -} - -namespace Android.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CompoundButtonEvents Events(this global::Android.Widget.CompoundButton item) => new CompoundButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TextViewEvents Events(this global::Android.Widget.TextView item) => new TextViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CompoundButtonEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Android.Widget.CompoundButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CompoundButtonEvents(global::Android.Widget.CompoundButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.CompoundButton.CheckedChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.CompoundButton.CheckedChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChange += x, x => _data.CheckedChange -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TextViewEvents : global::Android.Views.ViewEvents - { - private readonly global::Android.Widget.TextView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TextViewEvents(global::Android.Widget.TextView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AfterTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.AfterTextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BeforeTextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EditorAction => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Widget.TextView.EditorActionEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Text.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselViewEvents Events(this global::Xamarin.Forms.CarouselView item) => new CarouselViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static InputViewEvents Events(this global::Xamarin.Forms.InputView item) => new InputViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISwipeItemEvents Events(this global::Xamarin.Forms.ISwipeItem item) => new ISwipeItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RefreshViewEvents Events(this global::Xamarin.Forms.RefreshView item) => new RefreshViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemEvents Events(this global::Xamarin.Forms.SwipeItem item) => new SwipeItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemsEvents Events(this global::Xamarin.Forms.SwipeItems item) => new SwipeItemsEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemViewEvents Events(this global::Xamarin.Forms.SwipeItemView item) => new SwipeItemViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeViewEvents Events(this global::Xamarin.Forms.SwipeView item) => new SwipeViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.CarouselView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselViewEvents(global::Xamarin.Forms.CarouselView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CurrentItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PositionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class InputViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.InputView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public InputViewEvents(global::Xamarin.Forms.InputView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISwipeItemEvents - { - private readonly global::Xamarin.Forms.ISwipeItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISwipeItemEvents(global::Xamarin.Forms.ISwipeItem data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RefreshViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.RefreshView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RefreshViewEvents(global::Xamarin.Forms.RefreshView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.SwipeItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemEvents(global::Xamarin.Forms.SwipeItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemsEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeItems _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemsEvents(global::Xamarin.Forms.SwipeItems data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.SwipeItemView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemViewEvents(global::Xamarin.Forms.SwipeItemView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.SwipeView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeViewEvents(global::Xamarin.Forms.SwipeView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CloseRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeChanging => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeChangingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeEnded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeEndedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeEndedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeStarted => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeStartedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeStartedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Android -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase item) => new CheckBoxRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsAnimationDrawableEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAnimationDrawable item) => new FormsAnimationDrawableEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsAppCompatActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity item) => new FormsAppCompatActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsApplicationActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsApplicationActivity item) => new FormsApplicationActivityEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IBorderVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer item) => new IBorderVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDeviceInfoProviderEvents Events(this global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider item) => new IDeviceInfoProviderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IFormsAnimationDrawableEvents Events(this global::Xamarin.Forms.Platform.Android.IFormsAnimationDrawable item) => new IFormsAnimationDrawableEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ImageButtonRenderer item) => new ImageButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IndicatorViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IndicatorViewRenderer item) => new IndicatorViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellItemRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IShellItemRenderer item) => new IShellItemRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellObservableFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.IShellObservableFragment item) => new IShellObservableFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.IShellSearchView item) => new IShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.Android.MasterDetailRenderer item) => new MasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RefreshViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.RefreshViewRenderer item) => new RefreshViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableViewHolderEvents Events(this global::Xamarin.Forms.Platform.Android.SelectableViewHolder item) => new SelectableViewHolderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellContentFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.ShellContentFragment item) => new ShellContentFragmentEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellItemRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.ShellItemRendererBase item) => new ShellItemRendererBaseEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSearchView item) => new ShellSearchViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSectionRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSectionRenderer item) => new ShellSectionRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxRendererBaseEvents : global::Android.Widget.CompoundButtonEvents - { - private readonly global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxRendererBaseEvents(global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsAnimationDrawableEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsAnimationDrawable _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsAnimationDrawableEvents(global::Xamarin.Forms.Platform.Android.FormsAnimationDrawable data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStarted += x, x => _data.AnimationStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.FormsAnimationDrawableStateEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.FormsAnimationDrawableStateEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStopped += x, x => _data.AnimationStopped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsAppCompatActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsAppCompatActivityEvents(global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsApplicationActivityEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FormsApplicationActivity _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsApplicationActivityEvents(global::Xamarin.Forms.Platform.Android.FormsApplicationActivity data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IBorderVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IBorderVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDeviceInfoProviderEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDeviceInfoProviderEvents(global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ConfigurationChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IFormsAnimationDrawableEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IFormsAnimationDrawable _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IFormsAnimationDrawableEvents(global::Xamarin.Forms.Platform.Android.IFormsAnimationDrawable data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStarted += x, x => _data.AnimationStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.FormsAnimationDrawableStateEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.FormsAnimationDrawableStateEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStopped += x, x => _data.AnimationStopped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ImageButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonRendererEvents(global::Xamarin.Forms.Platform.Android.ImageButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IndicatorViewRendererEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IndicatorViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IndicatorViewRendererEvents(global::Xamarin.Forms.Platform.Android.IndicatorViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellItemRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellItemRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellItemRendererEvents(global::Xamarin.Forms.Platform.Android.IShellItemRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellObservableFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellObservableFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellObservableFragmentEvents(global::Xamarin.Forms.Platform.Android.IShellObservableFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.IShellSearchView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailRendererEvents : global::Android.Support.V4.Widget.DrawerLayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Android.MasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailRendererEvents(global::Xamarin.Forms.Platform.Android.MasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RefreshViewRendererEvents : global::Android.Support.V4.Widget.SwipeRefreshLayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Android.RefreshViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RefreshViewRendererEvents(global::Xamarin.Forms.Platform.Android.RefreshViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::Android.Support.V4.Widget.NestedScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.Android.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableViewHolderEvents - { - private readonly global::Xamarin.Forms.Platform.Android.SelectableViewHolder _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableViewHolderEvents(global::Xamarin.Forms.Platform.Android.SelectableViewHolder data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent, int>(eventHandler => - { - void Handler(object sender, int e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellContentFragmentEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellContentFragment _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellContentFragmentEvents(global::Xamarin.Forms.Platform.Android.ShellContentFragment data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellItemRendererBaseEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellItemRendererBase _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellItemRendererBaseEvents(global::Xamarin.Forms.Platform.Android.ShellItemRendererBase data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Destroyed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSearchView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.ShellSearchView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchConfirmed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSectionRendererEvents - { - private readonly global::Xamarin.Forms.Platform.Android.ShellSectionRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSectionRendererEvents(global::Xamarin.Forms.Platform.Android.ShellSectionRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); - } -} - -namespace Xamarin.Forms.Platform.Android.FastRenderers -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer item) => new ButtonRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FrameRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer item) => new FrameRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer item) => new ImageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LabelRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer item) => new LabelRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FrameRendererEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FrameRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageRendererEvents : global::Android.Views.ViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LabelRendererEvents : global::Android.Widget.TextViewEvents - { - private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LabelRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.netstandard2.0.approved.txt deleted file mode 100644 index 363bc73..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.netstandard2.0.approved.txt +++ /dev/null @@ -1,2899 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselViewEvents Events(this global::Xamarin.Forms.CarouselView item) => new CarouselViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static InputViewEvents Events(this global::Xamarin.Forms.InputView item) => new InputViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISwipeItemEvents Events(this global::Xamarin.Forms.ISwipeItem item) => new ISwipeItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RefreshViewEvents Events(this global::Xamarin.Forms.RefreshView item) => new RefreshViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemEvents Events(this global::Xamarin.Forms.SwipeItem item) => new SwipeItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemsEvents Events(this global::Xamarin.Forms.SwipeItems item) => new SwipeItemsEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemViewEvents Events(this global::Xamarin.Forms.SwipeItemView item) => new SwipeItemViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeViewEvents Events(this global::Xamarin.Forms.SwipeView item) => new SwipeViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.CarouselView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselViewEvents(global::Xamarin.Forms.CarouselView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CurrentItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PositionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class InputViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.InputView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public InputViewEvents(global::Xamarin.Forms.InputView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISwipeItemEvents - { - private readonly global::Xamarin.Forms.ISwipeItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISwipeItemEvents(global::Xamarin.Forms.ISwipeItem data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RefreshViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.RefreshView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RefreshViewEvents(global::Xamarin.Forms.RefreshView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.SwipeItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemEvents(global::Xamarin.Forms.SwipeItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemsEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeItems _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemsEvents(global::Xamarin.Forms.SwipeItems data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.SwipeItemView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemViewEvents(global::Xamarin.Forms.SwipeItemView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.SwipeView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeViewEvents(global::Xamarin.Forms.SwipeView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CloseRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeChanging => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeChangingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeEnded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeEndedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeEndedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeStarted => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeStartedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeStartedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.tizen40.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.tizen40.approved.txt deleted file mode 100644 index 3e3fb67..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.tizen40.approved.txt +++ /dev/null @@ -1,3965 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace ElmSharp -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::ElmSharp.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EvasObjectEvents Events(this global::ElmSharp.EvasObject item) => new EvasObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::ElmSharp.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PopupEvents Events(this global::ElmSharp.Popup item) => new PopupEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WidgetEvents Events(this global::ElmSharp.Widget item) => new WidgetEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::ElmSharp.LayoutEvents - { - private readonly global::ElmSharp.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::ElmSharp.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChangedByUser => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChangedByUser += x, x => _data.ChangedByUser -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CursorChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CursorChanged += x, x => _data.CursorChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EvasObjectEvents - { - private readonly global::ElmSharp.EvasObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EvasObjectEvents(global::ElmSharp.EvasObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Deleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Deleted += x, x => _data.Deleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyDown => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.EvasKeyEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable KeyUp => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.EvasKeyEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MoreButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MoreButtonPressed += x, x => _data.MoreButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Moved => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Moved += x, x => _data.Moved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RenderPost => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RenderPost += x, x => _data.RenderPost -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Resized => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Resized += x, x => _data.Resized -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::ElmSharp.WidgetEvents - { - private readonly global::ElmSharp.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::ElmSharp.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LanguageChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ThemeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ThemeChanged += x, x => _data.ThemeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PopupEvents : global::ElmSharp.LayoutEvents - { - private readonly global::ElmSharp.Popup _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PopupEvents(global::ElmSharp.Popup data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Dismissed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OutsideClicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OutsideClicked += x, x => _data.OutsideClicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ShowAnimationFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ShowAnimationFinished += x, x => _data.ShowAnimationFinished -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TimedOut => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TimedOut += x, x => _data.TimedOut -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WidgetEvents : global::ElmSharp.EvasObjectEvents - { - private readonly global::ElmSharp.Widget _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WidgetEvents(global::ElmSharp.Widget data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselViewEvents Events(this global::Xamarin.Forms.CarouselView item) => new CarouselViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static InputViewEvents Events(this global::Xamarin.Forms.InputView item) => new InputViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISwipeItemEvents Events(this global::Xamarin.Forms.ISwipeItem item) => new ISwipeItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RefreshViewEvents Events(this global::Xamarin.Forms.RefreshView item) => new RefreshViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemEvents Events(this global::Xamarin.Forms.SwipeItem item) => new SwipeItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemsEvents Events(this global::Xamarin.Forms.SwipeItems item) => new SwipeItemsEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemViewEvents Events(this global::Xamarin.Forms.SwipeItemView item) => new SwipeItemViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeViewEvents Events(this global::Xamarin.Forms.SwipeView item) => new SwipeViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.CarouselView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselViewEvents(global::Xamarin.Forms.CarouselView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CurrentItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PositionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class InputViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.InputView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public InputViewEvents(global::Xamarin.Forms.InputView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISwipeItemEvents - { - private readonly global::Xamarin.Forms.ISwipeItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISwipeItemEvents(global::Xamarin.Forms.ISwipeItem data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RefreshViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.RefreshView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RefreshViewEvents(global::Xamarin.Forms.RefreshView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.SwipeItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemEvents(global::Xamarin.Forms.SwipeItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemsEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeItems _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemsEvents(global::Xamarin.Forms.SwipeItems data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.SwipeItemView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemViewEvents(global::Xamarin.Forms.SwipeItemView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.SwipeView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeViewEvents(global::Xamarin.Forms.SwipeView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CloseRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeChanging => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeChangingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeEnded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeEndedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeEndedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeStarted => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeStartedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeStartedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DefaultPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.DefaultPlatform item) => new DefaultPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static GestureHandlerEvents Events(this global::Xamarin.Forms.Platform.Tizen.GestureHandler item) => new GestureHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationDrawerEvents Events(this global::Xamarin.Forms.Platform.Tizen.INavigationDrawer item) => new INavigationDrawerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationViewEvents Events(this global::Xamarin.Forms.Platform.Tizen.INavigationView item) => new INavigationViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellTabsEvents Events(this global::Xamarin.Forms.Platform.Tizen.IShellTabs item) => new IShellTabsEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITizenPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.ITizenPlatform item) => new ITizenPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LightweightPlatformEvents Events(this global::Xamarin.Forms.Platform.Tizen.LightweightPlatform item) => new LightweightPlatformEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationDrawerEvents Events(this global::Xamarin.Forms.Platform.Tizen.NavigationDrawer item) => new NavigationDrawerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationViewEvents Events(this global::Xamarin.Forms.Platform.Tizen.NavigationView item) => new NavigationViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DefaultPlatformEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.DefaultPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DefaultPlatformEvents(global::Xamarin.Forms.Platform.Tizen.DefaultPlatform data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class GestureHandlerEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.GestureHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public GestureHandlerEvents(global::Xamarin.Forms.Platform.Tizen.GestureHandler data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationDrawerEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.INavigationDrawer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationDrawerEvents(global::Xamarin.Forms.Platform.Tizen.INavigationDrawer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationViewEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.INavigationView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationViewEvents(global::Xamarin.Forms.Platform.Tizen.INavigationView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellTabsEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.IShellTabs _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellTabsEvents(global::Xamarin.Forms.Platform.Tizen.IShellTabs data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent, global::ElmSharp.ToolbarItemEventArgs>(eventHandler => - { - void Handler(object sender, global::ElmSharp.ToolbarItemEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITizenPlatformEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.ITizenPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITizenPlatformEvents(global::Xamarin.Forms.Platform.Tizen.ITizenPlatform data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LightweightPlatformEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.LightweightPlatform _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LightweightPlatformEvents(global::Xamarin.Forms.Platform.Tizen.LightweightPlatform data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RootNativeViewChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationDrawerEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.NavigationDrawer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationDrawerEvents(global::Xamarin.Forms.Platform.Tizen.NavigationDrawer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationViewEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.NavigationView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationViewEvents(global::Xamarin.Forms.Platform.Tizen.NavigationView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen.Native -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BoxEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Box item) => new BoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DateTimePickerDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog item) => new DateTimePickerDialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Dialog item) => new DialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditfieldEntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry item) => new EditfieldEntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDateTimeDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog item) => new IDateTimeDialogEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IEntryEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.IEntry item) => new IEntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemAdaptorEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.ItemAdaptor item) => new ItemAdaptorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ViewHolderEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.ViewHolder item) => new ViewHolderEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BoxEvents : global::ElmSharp.WidgetEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Box _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BoxEvents(global::Xamarin.Forms.Platform.Tizen.Native.Box data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DateTimePickerDialogEvents : global::Xamarin.Forms.Platform.Tizen.Native.DialogEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DateTimePickerDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.DateTimePickerDialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DialogEvents : global::ElmSharp.PopupEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Dialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.Dialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Shown => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Shown += x, x => _data.Shown -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditfieldEntryEvents : global::Xamarin.Forms.Platform.Tizen.Native.EntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditfieldEntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.EditfieldEntry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutFocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutFocused += x, x => _data.LayoutFocused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutUnfocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutUnfocused += x, x => _data.LayoutUnfocused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextBlockFocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextBlockFocused += x, x => _data.TextBlockFocused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextBlockUnfocused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextBlockUnfocused += x, x => _data.TextBlockUnfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::ElmSharp.EntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDateTimeDialogEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDateTimeDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.IDateTimeDialog data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IEntryEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.IEntry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IEntryEvents(global::Xamarin.Forms.Platform.Tizen.Native.IEntry data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemAdaptorEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.ItemAdaptor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemAdaptorEvents(global::Xamarin.Forms.Platform.Tizen.Native.ItemAdaptor data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.Platform.Tizen.Native.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.IsPresentedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.IsPresentedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable UpdateIsPresentChangeable => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.UpdateIsPresentChangeableEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.UpdateIsPresentChangeableEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.UpdateIsPresentChangeable += x, x => _data.UpdateIsPresentChangeable -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::ElmSharp.LayoutEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Platform.Tizen.Native.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ViewHolderEvents : global::Xamarin.Forms.Platform.Tizen.Native.BoxEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.ViewHolder _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ViewHolderEvents(global::Xamarin.Forms.Platform.Tizen.Native.ViewHolder data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RequestSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RequestSelected += x, x => _data.RequestSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Selected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); - } -} - -namespace Xamarin.Forms.Platform.Tizen.Native.Watch -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WatchDataTimePickerDialogEvents Events(this global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog item) => new WatchDataTimePickerDialogEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WatchDataTimePickerDialogEvents : global::ElmSharp.PopupEvents - { - private readonly global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WatchDataTimePickerDialogEvents(global::Xamarin.Forms.Platform.Tizen.Native.Watch.WatchDataTimePickerDialog data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateTimeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.uap10.0.17763.approved.txt deleted file mode 100644 index 91897fc..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.uap10.0.17763.approved.txt +++ /dev/null @@ -1,3249 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselViewEvents Events(this global::Xamarin.Forms.CarouselView item) => new CarouselViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static InputViewEvents Events(this global::Xamarin.Forms.InputView item) => new InputViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISwipeItemEvents Events(this global::Xamarin.Forms.ISwipeItem item) => new ISwipeItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RefreshViewEvents Events(this global::Xamarin.Forms.RefreshView item) => new RefreshViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemEvents Events(this global::Xamarin.Forms.SwipeItem item) => new SwipeItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemsEvents Events(this global::Xamarin.Forms.SwipeItems item) => new SwipeItemsEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemViewEvents Events(this global::Xamarin.Forms.SwipeItemView item) => new SwipeItemViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeViewEvents Events(this global::Xamarin.Forms.SwipeView item) => new SwipeViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.CarouselView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselViewEvents(global::Xamarin.Forms.CarouselView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CurrentItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PositionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class InputViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.InputView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public InputViewEvents(global::Xamarin.Forms.InputView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISwipeItemEvents - { - private readonly global::Xamarin.Forms.ISwipeItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISwipeItemEvents(global::Xamarin.Forms.ISwipeItem data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RefreshViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.RefreshView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RefreshViewEvents(global::Xamarin.Forms.RefreshView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.SwipeItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemEvents(global::Xamarin.Forms.SwipeItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemsEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeItems _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemsEvents(global::Xamarin.Forms.SwipeItems data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.SwipeItemView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemViewEvents(global::Xamarin.Forms.SwipeItemView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.SwipeView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeViewEvents(global::Xamarin.Forms.SwipeView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CloseRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeChanging => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeChangingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeEnded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeEndedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeEndedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeStarted => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeStartedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeStartedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.UWP -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellRendererCompletedEvents Events(this global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted item) => new EntryCellRendererCompletedEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsFlyoutEvents Events(this global::Xamarin.Forms.Platform.UWP.FormsFlyout item) => new FormsFlyoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer item) => new MasterDetailPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer item) => new NavigationPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperControlEvents Events(this global::Xamarin.Forms.Platform.UWP.StepperControl item) => new StepperControlEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedPageRendererEvents Events(this global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer item) => new TabbedPageRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.UWP.CarouselPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellRendererCompletedEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellRendererCompletedEvents(global::Xamarin.Forms.Platform.UWP.EntryCellRendererCompleted data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsFlyoutEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.FormsFlyout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsFlyoutEvents(global::Xamarin.Forms.Platform.UWP.FormsFlyout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OptionSelected => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OptionSelected += x, x => _data.OptionSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.UWP.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.UWP.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageRendererEvents(global::Xamarin.Forms.Platform.UWP.MasterDetailPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageRendererEvents(global::Xamarin.Forms.Platform.UWP.NavigationPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperControlEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.StepperControl _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperControlEvents(global::Xamarin.Forms.Platform.UWP.StepperControl data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedPageRendererEvents(global::Xamarin.Forms.Platform.UWP.TabbedPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.WinRT -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperControlEvents Events(this global::Xamarin.Forms.Platform.WinRT.StepperControl item) => new StepperControlEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperControlEvents - { - private readonly global::Xamarin.Forms.Platform.WinRT.StepperControl _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperControlEvents(global::Xamarin.Forms.Platform.WinRT.StepperControl data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.xamarinios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.xamarinios10.approved.txt deleted file mode 100644 index dbd2146..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.xamarinios10.approved.txt +++ /dev/null @@ -1,3987 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace UIKit -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UIScrollViewEvents Events(this global::UIKit.UIScrollView item) => new UIScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UISplitViewControllerEvents Events(this global::UIKit.UISplitViewController item) => new UISplitViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UITabBarControllerEvents Events(this global::UIKit.UITabBarController item) => new UITabBarControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static UIWebViewEvents Events(this global::UIKit.UIWebView item) => new UIWebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UIScrollViewEvents - { - private readonly global::UIKit.UIScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UIScrollViewEvents(global::UIKit.UIScrollView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DecelerationEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DecelerationEnded += x, x => _data.DecelerationEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DecelerationStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DecelerationStarted += x, x => _data.DecelerationStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidChangeAdjustedContentInset => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidChangeAdjustedContentInset += x, x => _data.DidChangeAdjustedContentInset -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidZoom => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidZoom += x, x => _data.DidZoom -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DraggingEnded => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.DraggingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.DraggingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DraggingEnded += x, x => _data.DraggingEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DraggingStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DraggingStarted += x, x => _data.DraggingStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollAnimationEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollAnimationEnded += x, x => _data.ScrollAnimationEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrolledToTop => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrolledToTop += x, x => _data.ScrolledToTop -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillEndDragging => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.WillEndDraggingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.WillEndDraggingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillEndDragging += x, x => _data.WillEndDragging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ZoomingEnded => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.ZoomingEndedEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.ZoomingEndedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ZoomingEnded += x, x => _data.ZoomingEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ZoomingStarted => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIScrollViewZoomingEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UIScrollViewZoomingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ZoomingStarted += x, x => _data.ZoomingStarted -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UISplitViewControllerEvents - { - private readonly global::UIKit.UISplitViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UISplitViewControllerEvents(global::UIKit.UISplitViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillChangeDisplayMode => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewControllerDisplayModeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewControllerDisplayModeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillChangeDisplayMode += x, x => _data.WillChangeDisplayMode -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillHideViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewHideEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewHideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillHideViewController += x, x => _data.WillHideViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillPresentViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewPresentEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewPresentEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillPresentViewController += x, x => _data.WillPresentViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillShowViewController => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UISplitViewShowEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UISplitViewShowEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillShowViewController += x, x => _data.WillShowViewController -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UITabBarControllerEvents - { - private readonly global::UIKit.UITabBarController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UITabBarControllerEvents(global::UIKit.UITabBarController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FinishedCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FinishedCustomizingViewControllers += x, x => _data.FinishedCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnCustomizingViewControllers += x, x => _data.OnCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnEndCustomizingViewControllers => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarCustomizeChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarCustomizeChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnEndCustomizingViewControllers += x, x => _data.OnEndCustomizingViewControllers -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ViewControllerSelected => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UITabBarSelectionEventArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UITabBarSelectionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ViewControllerSelected += x, x => _data.ViewControllerSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class UIWebViewEvents - { - private readonly global::UIKit.UIWebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public UIWebViewEvents(global::UIKit.UIWebView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadError => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIWebErrorArgs>(eventHandler => - { - void Handler(object sender, global::UIKit.UIWebErrorArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadError += x, x => _data.LoadError -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadFinished => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadFinished += x, x => _data.LoadFinished -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LoadStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LoadStarted += x, x => _data.LoadStarted -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselViewEvents Events(this global::Xamarin.Forms.CarouselView item) => new CarouselViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static InputViewEvents Events(this global::Xamarin.Forms.InputView item) => new InputViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISwipeItemEvents Events(this global::Xamarin.Forms.ISwipeItem item) => new ISwipeItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RefreshViewEvents Events(this global::Xamarin.Forms.RefreshView item) => new RefreshViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemEvents Events(this global::Xamarin.Forms.SwipeItem item) => new SwipeItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemsEvents Events(this global::Xamarin.Forms.SwipeItems item) => new SwipeItemsEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemViewEvents Events(this global::Xamarin.Forms.SwipeItemView item) => new SwipeItemViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeViewEvents Events(this global::Xamarin.Forms.SwipeView item) => new SwipeViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.CarouselView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselViewEvents(global::Xamarin.Forms.CarouselView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CurrentItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PositionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class InputViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.InputView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public InputViewEvents(global::Xamarin.Forms.InputView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISwipeItemEvents - { - private readonly global::Xamarin.Forms.ISwipeItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISwipeItemEvents(global::Xamarin.Forms.ISwipeItem data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RefreshViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.RefreshView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RefreshViewEvents(global::Xamarin.Forms.RefreshView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.SwipeItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemEvents(global::Xamarin.Forms.SwipeItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemsEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeItems _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemsEvents(global::Xamarin.Forms.SwipeItems data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.SwipeItemView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemViewEvents(global::Xamarin.Forms.SwipeItemView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.SwipeView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeViewEvents(global::Xamarin.Forms.SwipeView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CloseRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeChanging => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeChangingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeEnded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeEndedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeEndedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeStarted => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeStartedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeStartedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.iOS -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static FormsUIImageViewEvents Events(this global::Xamarin.Forms.Platform.iOS.FormsUIImageView item) => new FormsUIImageViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellFlyoutContentRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer item) => new IShellFlyoutContentRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSearchResultsRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer item) => new IShellSearchResultsRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterViewEvents Events(this global::Xamarin.Forms.Platform.iOS.EventedViewController.MasterView item) => new MasterViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.NavigationRenderer item) => new NavigationRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.PageRenderer item) => new PageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PhoneMasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer item) => new PhoneMasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellFlyoutContentRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer item) => new ShellFlyoutContentRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellRenderer item) => new ShellRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellSearchResultsRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer item) => new ShellSearchResultsRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellTableViewSourceEvents Events(this global::Xamarin.Forms.Platform.iOS.ShellTableViewSource item) => new ShellTableViewSourceEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.TabbedRenderer item) => new TabbedRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabletMasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer item) => new TabletMasterDetailRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TemplatedCellEvents Events(this global::Xamarin.Forms.Platform.iOS.TemplatedCell item) => new TemplatedCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementTrackerEvents Events(this global::Xamarin.Forms.Platform.iOS.VisualElementTracker item) => new VisualElementTrackerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - [global::System.ObsoleteAttribute("WebViewRenderer is obsolete as of 4.4.0. Please use the WkWebViewRenderer instead.", false)] - public static WebViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.WebViewRenderer item) => new WebViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WkWebViewRendererEvents Events(this global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer item) => new WkWebViewRendererEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.iOS.CarouselPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class FormsUIImageViewEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.FormsUIImageView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public FormsUIImageViewEvents(global::Xamarin.Forms.Platform.iOS.FormsUIImageView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable AnimationStopped => global::System.Reactive.Linq.Observable.FromEvent, global::CoreAnimation.CAAnimationStateEventArgs>(eventHandler => - { - void Handler(object sender, global::CoreAnimation.CAAnimationStateEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.AnimationStopped += x, x => _data.AnimationStopped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IButtonLayoutRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.iOS.IButtonLayoutRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ElementChanged => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Platform.iOS.ElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.ElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellFlyoutContentRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellFlyoutContentRendererEvents(global::Xamarin.Forms.Platform.iOS.IShellFlyoutContentRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillAppear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillAppear += x, x => _data.WillAppear -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillDisappear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSearchResultsRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSearchResultsRendererEvents(global::Xamarin.Forms.Platform.iOS.IShellSearchResultsRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => - { - void Handler(object sender, object e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.iOS.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.iOS.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterViewEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.EventedViewController.MasterView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterViewEvents(global::Xamarin.Forms.Platform.iOS.EventedViewController.MasterView data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidAppear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidAppear += x, x => _data.DidAppear -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillDisappear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.NavigationRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationRendererEvents(global::Xamarin.Forms.Platform.iOS.NavigationRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.PageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageRendererEvents(global::Xamarin.Forms.Platform.iOS.PageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PhoneMasterDetailRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PhoneMasterDetailRendererEvents(global::Xamarin.Forms.Platform.iOS.PhoneMasterDetailRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents : global::UIKit.UIScrollViewEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.iOS.ScrollViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellFlyoutContentRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellFlyoutContentRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellFlyoutContentRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillAppear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillAppear += x, x => _data.WillAppear -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillDisappear => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillDisappear += x, x => _data.WillDisappear -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellSearchResultsRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellSearchResultsRendererEvents(global::Xamarin.Forms.Platform.iOS.ShellSearchResultsRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, object>(eventHandler => - { - void Handler(object sender, object e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellTableViewSourceEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.ShellTableViewSource _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellTableViewSourceEvents(global::Xamarin.Forms.Platform.iOS.ShellTableViewSource data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrolledEvent => global::System.Reactive.Linq.Observable.FromEvent, global::UIKit.UIScrollView>(eventHandler => - { - void Handler(object sender, global::UIKit.UIScrollView e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrolledEvent += x, x => _data.ScrolledEvent -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedRendererEvents : global::UIKit.UITabBarControllerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TabbedRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedRendererEvents(global::Xamarin.Forms.Platform.iOS.TabbedRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabletMasterDetailRendererEvents : global::UIKit.UISplitViewControllerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabletMasterDetailRendererEvents(global::Xamarin.Forms.Platform.iOS.TabletMasterDetailRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TemplatedCellEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.TemplatedCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TemplatedCellEvents(global::Xamarin.Forms.Platform.iOS.TemplatedCell data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ContentSizeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ContentSizeChanged += x, x => _data.ContentSizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementTrackerEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.VisualElementTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementTrackerEvents(global::Xamarin.Forms.Platform.iOS.VisualElementTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NativeControlUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - [global::System.ObsoleteAttribute("WebViewRenderer is obsolete as of 4.4.0. Please use the WkWebViewRenderer instead.", false)] - public class WebViewRendererEvents : global::UIKit.UIWebViewEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.WebViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewRendererEvents(global::Xamarin.Forms.Platform.iOS.WebViewRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WkWebViewRendererEvents - { - private readonly global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WkWebViewRendererEvents(global::Xamarin.Forms.Platform.iOS.WkWebViewRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.iOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.xamarinmac20.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.xamarinmac20.approved.txt deleted file mode 100644 index 28db8e3..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.xamarinmac20.approved.txt +++ /dev/null @@ -1,3316 +0,0 @@ -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; - -namespace AppKit -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NSPageControllerEvents Events(this global::AppKit.NSPageController item) => new NSPageControllerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NSPageControllerEvents - { - private readonly global::AppKit.NSPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NSPageControllerEvents(global::AppKit.NSPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidEndLiveTransition => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidEndLiveTransition += x, x => _data.DidEndLiveTransition -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DidTransition => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPageControllerTransitionEventArgs>(eventHandler => - { - void Handler(object sender, global::AppKit.NSPageControllerTransitionEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DidTransition += x, x => _data.DidTransition -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PrepareViewController => global::System.Reactive.Linq.Observable.FromEvent, global::AppKit.NSPageControllerPrepareViewControllerEventArgs>(eventHandler => - { - void Handler(object sender, global::AppKit.NSPageControllerPrepareViewControllerEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PrepareViewController += x, x => _data.PrepareViewController -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable WillStartLiveTransition => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.WillStartLiveTransition += x, x => _data.WillStartLiveTransition -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselViewEvents Events(this global::Xamarin.Forms.CarouselView item) => new CarouselViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static InputViewEvents Events(this global::Xamarin.Forms.InputView item) => new InputViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ISwipeItemEvents Events(this global::Xamarin.Forms.ISwipeItem item) => new ISwipeItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RefreshViewEvents Events(this global::Xamarin.Forms.RefreshView item) => new RefreshViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemEvents Events(this global::Xamarin.Forms.SwipeItem item) => new SwipeItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemsEvents Events(this global::Xamarin.Forms.SwipeItems item) => new SwipeItemsEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeItemViewEvents Events(this global::Xamarin.Forms.SwipeItemView item) => new SwipeItemViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeViewEvents Events(this global::Xamarin.Forms.SwipeView item) => new SwipeViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Application _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPopping => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPoppingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModalPushing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ModalPushingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PageDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Page>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); - return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.BaseShellItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class BindableObjectEvents - { - private readonly global::Xamarin.Forms.BindableObject _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BindingContextChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Button _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.CarouselView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselViewEvents(global::Xamarin.Forms.CarouselView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CurrentItemChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CurrentItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PositionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PositionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CellEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.Cell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.CheckBox _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ChildGestureRecognizerEvents - { - private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.ColumnDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CommandEvents - { - private readonly global::Xamarin.Forms.Command _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CanExecuteChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.DatePicker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DateSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EditorEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.Editor _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.Element _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantAdded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DescendantRemoved => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ElementEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.Entry _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.EntryCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Completed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ICellControllerEvents - { - private readonly global::Xamarin.Forms.ICellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ForceUpdateSizeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IDefinitionEvents - { - private readonly global::Xamarin.Forms.IDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IElementControllerEvents - { - private readonly global::Xamarin.Forms.IElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("PlatformSet is obsolete as of 3.5.0. Do not use this event.", false)] - public global::System.IObservable PlatformSet => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ILayoutEvents - { - private readonly global::Xamarin.Forms.ILayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListProxyEvents - { - private readonly global::Xamarin.Forms.IListProxy _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IListViewControllerEvents - { - private readonly global::Xamarin.Forms.IListViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ImageButton _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Released => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IMasterDetailPageControllerEvents - { - private readonly global::Xamarin.Forms.IMasterDetailPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class INavigationPageControllerEvents - { - private readonly global::Xamarin.Forms.INavigationPageController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class InputViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.InputView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public InputViewEvents(global::Xamarin.Forms.InputView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable TextChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.TextChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IOpenGlViewControllerEvents - { - private readonly global::Xamarin.Forms.IOpenGlViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IScrollViewControllerEvents - { - private readonly global::Xamarin.Forms.IScrollViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISearchHandlerControllerEvents - { - private readonly global::Xamarin.Forms.ISearchHandlerController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ListProxyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ListProxyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellControllerEvents - { - private readonly global::Xamarin.Forms.IShellController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable StructureChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IShellSectionControllerEvents - { - private readonly global::Xamarin.Forms.IShellSectionController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NavigationRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ISwipeItemEvents - { - private readonly global::Xamarin.Forms.ISwipeItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ISwipeItemEvents(global::Xamarin.Forms.ISwipeItem data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ITableViewControllerEvents - { - private readonly global::Xamarin.Forms.ITableViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemainingItemsThresholdReached => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemsViewScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementControllerEvents - { - private readonly global::Xamarin.Forms.IVisualElementController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IWebViewControllerEvents - { - private readonly global::Xamarin.Forms.IWebViewController _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Layout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.ListView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemAppearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemDisappearing => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemVisibilityEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemSelected => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectedItemChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ItemTapped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ItemTappedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.MasterDetailPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable BackButtonPressed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.BackButtonPressedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable IsPresentedChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.MenuItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Clicked => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.NavigationPage _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable InsertPageBeforeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Popped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PoppedToRoot => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PopToRootRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Pushed => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.NavigationEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PushRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable RemovePageRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.OpenGLView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DisplayRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Page _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Appearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Disappearing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable LayoutChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PanGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PanUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PanUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Picker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectedIndexChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PinchUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PinchGestureUpdatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RefreshViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.RefreshView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RefreshViewEvents(global::Xamarin.Forms.RefreshView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refreshing => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.RowDefinition _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.ScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Scrolled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrolledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollToRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ScrollToRequestedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchBarEvents : global::Xamarin.Forms.InputViewEvents - { - private readonly global::Xamarin.Forms.SearchBar _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SearchButtonPressed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents - { - private readonly global::Xamarin.Forms.SearchHandler _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents - { - private readonly global::Xamarin.Forms.SelectableItemsView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SelectionChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SelectionChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ShellEvents : global::Xamarin.Forms.PageEvents - { - private readonly global::Xamarin.Forms.Shell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ShellNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Slider _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DragStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Stepper _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValueChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ValueChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Swiped => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.SwipeItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemEvents(global::Xamarin.Forms.SwipeItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemsEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.SwipeItems _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemsEvents(global::Xamarin.Forms.SwipeItems data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeItemViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.SwipeItemView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeItemViewEvents(global::Xamarin.Forms.SwipeItemView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Invoked => global::System.Reactive.Linq.Observable.FromEvent, global::System.EventArgs>(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeViewEvents : global::Xamarin.Forms.LayoutEvents - { - private readonly global::Xamarin.Forms.SwipeView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeViewEvents(global::Xamarin.Forms.SwipeView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CloseRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeChanging => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeChangingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeEnded => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeEndedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeEndedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SwipeStarted => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeStartedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.SwipeStartedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.Switch _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Toggled => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents - { - private readonly global::Xamarin.Forms.SwitchCell _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable OnChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ToggledEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.TableView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ModelChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.TapGestureRecognizer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents - { - private readonly global::Xamarin.Forms.ToolbarItem _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - [global::System.ObsoleteAttribute("Activated is obsolete as of version 1.3.0. Please use Clicked instead.", false)] - public global::System.IObservable Activated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents - { - private readonly global::Xamarin.Forms.VisualElement _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> BatchCommitted => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ChildrenReordered => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable FocusChangeRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.VisualElement.FocusRequestArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Focused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable MeasureInvalidated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable SizeChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Unfocused => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.FocusEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents - { - private readonly global::Xamarin.Forms.WebView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable EvalRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.EvalRequested>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); - return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoBackRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable GoForwardRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Navigating => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.WebNavigatingEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ReloadRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); - } -} - -namespace Xamarin.Forms.Internals -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DeviceInfoEvents - { - private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable PropertyChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IResourceDictionaryEvents - { - private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ValuesChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TableModelEvents - { - private readonly global::Xamarin.Forms.Internals.TableModel _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemLongPressed => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable> ItemSelected => global::System.Reactive.Linq.Observable.FromEvent>, global::Xamarin.Forms.Internals.EventArg>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); - return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ToolbarTrackerEvents - { - private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); - } -} - -namespace Xamarin.Forms.Platform.MacOS -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static CarouselPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer item) => new CarouselPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static IVisualNativeElementRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer item) => new IVisualNativeElementRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static MasterDetailPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer item) => new MasterDetailPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NavigationPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer item) => new NavigationPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static PageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.PageRenderer item) => new PageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static TabbedPageRendererEvents Events(this global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer item) => new TabbedPageRendererEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static VisualElementTrackerEvents Events(this global::Xamarin.Forms.Platform.MacOS.VisualElementTracker item) => new VisualElementTrackerEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class CarouselPageRendererEvents : global::AppKit.NSPageControllerEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public CarouselPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.CarouselPageRenderer data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.MacOS.IVisualElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class IVisualNativeElementRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public IVisualNativeElementRendererEvents(global::Xamarin.Forms.Platform.MacOS.IVisualNativeElementRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ControlChanging => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class MasterDetailPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public MasterDetailPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.MasterDetailPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NavigationPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NavigationPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.NavigationPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class PageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.PageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public PageRendererEvents(global::Xamarin.Forms.Platform.MacOS.PageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class ScrollViewRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.MacOS.ScrollViewRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class TabbedPageRendererEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public TabbedPageRendererEvents(global::Xamarin.Forms.Platform.MacOS.TabbedPageRenderer data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.Platform.MacOS.VisualElementChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class VisualElementTrackerEvents - { - private readonly global::Xamarin.Forms.Platform.MacOS.VisualElementTracker _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public VisualElementTrackerEvents(global::Xamarin.Forms.Platform.MacOS.VisualElementTracker data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable NativeControlUpdated => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.NativeControlUpdated += x, x => _data.NativeControlUpdated -= x); - } -} - -namespace Xamarin.Forms -{ - /// - /// A class that contains extension methods to wrap events contained within static classes within the namespace. - /// - public static class Events - { - /// - /// Gets an observable which signals when the event triggers. - /// - public static global::System.IObservable FormsViewInitialized => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.ViewInitializedEventArgs>(eventHandler => - { - void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); - } -} - -namespace Xamarin.Forms.Platform.MacOS -{ - /// - /// Wraps delegates events from into Observables. - /// - public abstract partial class FormsApplicationDelegateRx : global::Xamarin.Forms.Platform.MacOS.FormsApplicationDelegate - { - private readonly Pharmacist.Common.SingleAwaitSubject _setupMainAppMenu = new Pharmacist.Common.SingleAwaitSubject(); - /// - /// Gets an observable which signals when the method is invoked. - /// - public global::System.IObservable SetupMainAppMenuObs => _setupMainAppMenu; - /// - public override void SetupMainAppMenu(global::AppKit.NSMenu nativeMenu) => _setupMainAppMenu.OnNext(nativeMenu); - } -} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.monoandroid81.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.monoandroid81.approved.txt deleted file mode 100644 index 4e6b9d6..0000000 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.monoandroid81.approved.txt +++ /dev/null @@ -1,6 +0,0 @@ - -using global::System; -using global::System.Reactive; -using global::System.Reactive.Linq; -using global::System.Reactive.Subjects; -using global::Pharmacist.Common; \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.monoandroid90.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.monoandroid10.0.approved.txt similarity index 69% rename from src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.monoandroid90.approved.txt rename to src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.monoandroid10.0.approved.txt index 11e1f66..c4ac9ef 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.4.0.991265.monoandroid90.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.monoandroid10.0.approved.txt @@ -1,142 +1,10 @@ + using global::System; using global::System.Reactive; using global::System.Reactive.Linq; using global::System.Reactive.Subjects; using global::Pharmacist.Common; -namespace Android.Support.V4.Widget -{ - /// - /// A class that contains extension methods to wrap events for classes contained within the namespace. - /// - public static class EventExtensions - { - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static DrawerLayoutEvents Events(this global::Android.Support.V4.Widget.DrawerLayout item) => new DrawerLayoutEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static NestedScrollViewEvents Events(this global::Android.Support.V4.Widget.NestedScrollView item) => new NestedScrollViewEvents(item); - /// - /// A wrapper class which wraps all the events contained within the class. - /// - public static SwipeRefreshLayoutEvents Events(this global::Android.Support.V4.Widget.SwipeRefreshLayout item) => new SwipeRefreshLayoutEvents(item); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class DrawerLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.DrawerLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public DrawerLayoutEvents(global::Android.Support.V4.Widget.DrawerLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerSlide => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable DrawerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class NestedScrollViewEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.NestedScrollView _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public NestedScrollViewEvents(global::Android.Support.V4.Widget.NestedScrollView data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs>(eventHandler => - { - void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); - } - - /// - /// A class which wraps the events contained within the class as observables. - /// - public class SwipeRefreshLayoutEvents : global::Android.Views.ViewGroupEvents - { - private readonly global::Android.Support.V4.Widget.SwipeRefreshLayout _data; - /// - /// Initializes a new instance of the class. - /// - /// The class that is being wrapped. - public SwipeRefreshLayoutEvents(global::Android.Support.V4.Widget.SwipeRefreshLayout data): base(data) - { - _data = data; - } - - /// - /// Gets an observable which signals when the event triggers. - /// - public global::System.IObservable Refresh => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => - { - void Handler(object sender, global::System.EventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.Refresh += x, x => _data.Refresh -= x); - } -} - namespace Android.Views { /// @@ -147,24 +15,24 @@ namespace Android.Views /// /// A wrapper class which wraps all the events contained within the class. /// - public static ViewEvents Events(this global::Android.Views.View item) => new ViewEvents(item); + public static RxViewEvents Events(this global::Android.Views.View item) => new RxViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ViewGroupEvents Events(this global::Android.Views.ViewGroup item) => new ViewGroupEvents(item); + public static RxViewGroupEvents Events(this global::Android.Views.ViewGroup item) => new RxViewGroupEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ViewEvents + public class RxViewEvents { private readonly global::Android.Views.View _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ViewEvents(global::Android.Views.View data) + public RxViewEvents(global::Android.Views.View data) { _data = data; } @@ -176,9 +44,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); + }, x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -186,9 +52,7 @@ namespace Android.Views { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -196,9 +60,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); + }, x => _data.ContextClick += x, x => _data.ContextClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -206,9 +68,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); + }, x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -216,9 +76,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); + }, x => _data.Drag += x, x => _data.Drag -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -226,9 +84,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); + }, x => _data.FocusChange += x, x => _data.FocusChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -236,9 +92,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); + }, x => _data.GenericMotion += x, x => _data.GenericMotion -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -246,9 +100,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); + }, x => _data.Hover += x, x => _data.Hover -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -256,9 +108,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -266,9 +116,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); + }, x => _data.LayoutChange += x, x => _data.LayoutChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -276,9 +124,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); + }, x => _data.LongClick += x, x => _data.LongClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -286,9 +132,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); + }, x => _data.ScrollChange += x, x => _data.ScrollChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -296,9 +140,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); + }, x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -306,9 +148,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); + }, x => _data.Touch += x, x => _data.Touch -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -316,9 +156,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.UnhandledKeyEventEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UnhandledKeyEvent += x, x => _data.UnhandledKeyEvent -= x); + }, x => _data.UnhandledKeyEvent += x, x => _data.UnhandledKeyEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -326,9 +164,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); + }, x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -336,22 +172,20 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); + }, x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ViewGroupEvents : global::Android.Views.ViewEvents + public class RxViewGroupEvents : global::Android.Views.RxViewEvents { private readonly global::Android.Views.ViewGroup _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ViewGroupEvents(global::Android.Views.ViewGroup data): base(data) + public RxViewGroupEvents(global::Android.Views.ViewGroup data): base(data) { _data = data; } @@ -363,9 +197,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); + }, x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -373,9 +205,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); + }, x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -383,9 +213,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); + }, x => _data.AnimationStart += x, x => _data.AnimationStart -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -393,9 +221,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); + }, x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -403,9 +229,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); + }, x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); } } @@ -419,24 +243,24 @@ namespace Android.Widget /// /// A wrapper class which wraps all the events contained within the class. /// - public static CompoundButtonEvents Events(this global::Android.Widget.CompoundButton item) => new CompoundButtonEvents(item); + public static RxCompoundButtonEvents Events(this global::Android.Widget.CompoundButton item) => new RxCompoundButtonEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TextViewEvents Events(this global::Android.Widget.TextView item) => new TextViewEvents(item); + public static RxTextViewEvents Events(this global::Android.Widget.TextView item) => new RxTextViewEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class CompoundButtonEvents : global::Android.Widget.TextViewEvents + public class RxCompoundButtonEvents : global::Android.Widget.RxTextViewEvents { private readonly global::Android.Widget.CompoundButton _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CompoundButtonEvents(global::Android.Widget.CompoundButton data): base(data) + public RxCompoundButtonEvents(global::Android.Widget.CompoundButton data): base(data) { _data = data; } @@ -448,22 +272,20 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.CompoundButton.CheckedChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChange += x, x => _data.CheckedChange -= x); + }, x => _data.CheckedChange += x, x => _data.CheckedChange -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TextViewEvents : global::Android.Views.ViewEvents + public class RxTextViewEvents : global::Android.Views.RxViewEvents { private readonly global::Android.Widget.TextView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TextViewEvents(global::Android.Widget.TextView data): base(data) + public RxTextViewEvents(global::Android.Widget.TextView data): base(data) { _data = data; } @@ -475,9 +297,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); + }, x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -485,9 +305,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); + }, x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -495,9 +313,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); + }, x => _data.EditorAction += x, x => _data.EditorAction -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -505,9 +321,148 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); return Handler; + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); + } +} + +namespace AndroidX.Core.Widget +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxNestedScrollViewEvents Events(this global::AndroidX.Core.Widget.NestedScrollView item) => new RxNestedScrollViewEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxNestedScrollViewEvents : global::Android.Views.RxViewGroupEvents + { + private readonly global::AndroidX.Core.Widget.NestedScrollView _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxNestedScrollViewEvents(global::AndroidX.Core.Widget.NestedScrollView data): base(data) + { + _data = data; } - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ScrollChange => global::System.Reactive.Linq.Observable.FromEvent, global::AndroidX.Core.Widget.NestedScrollView.ScrollChangeEventArgs>(eventHandler => + { + void Handler(object sender, global::AndroidX.Core.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ScrollChange += x, x => _data.ScrollChange -= x); + } +} + +namespace AndroidX.DrawerLayout.Widget +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDrawerLayoutEvents Events(this global::AndroidX.DrawerLayout.Widget.DrawerLayout item) => new RxDrawerLayoutEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDrawerLayoutEvents : global::Android.Views.RxViewGroupEvents + { + private readonly global::AndroidX.DrawerLayout.Widget.DrawerLayout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDrawerLayoutEvents(global::AndroidX.DrawerLayout.Widget.DrawerLayout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawerClosed => global::System.Reactive.Linq.Observable.FromEvent, global::AndroidX.DrawerLayout.Widget.DrawerLayout.DrawerClosedEventArgs>(eventHandler => + { + void Handler(object sender, global::AndroidX.DrawerLayout.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawerOpened => global::System.Reactive.Linq.Observable.FromEvent, global::AndroidX.DrawerLayout.Widget.DrawerLayout.DrawerOpenedEventArgs>(eventHandler => + { + void Handler(object sender, global::AndroidX.DrawerLayout.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawerSlide => global::System.Reactive.Linq.Observable.FromEvent, global::AndroidX.DrawerLayout.Widget.DrawerLayout.DrawerSlideEventArgs>(eventHandler => + { + void Handler(object sender, global::AndroidX.DrawerLayout.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DrawerStateChanged => global::System.Reactive.Linq.Observable.FromEvent, global::AndroidX.DrawerLayout.Widget.DrawerLayout.DrawerStateChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::AndroidX.DrawerLayout.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); + } +} + +namespace AndroidX.SwipeRefreshLayout.Widget +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxSwipeRefreshLayoutEvents Events(this global::AndroidX.SwipeRefreshLayout.Widget.SwipeRefreshLayout item) => new RxSwipeRefreshLayoutEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxSwipeRefreshLayoutEvents : global::Android.Views.RxViewGroupEvents + { + private readonly global::AndroidX.SwipeRefreshLayout.Widget.SwipeRefreshLayout _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxSwipeRefreshLayoutEvents(global::AndroidX.SwipeRefreshLayout.Widget.SwipeRefreshLayout data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Refresh => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Refresh += x, x => _data.Refresh -= x); } } @@ -521,284 +476,320 @@ namespace Xamarin.Forms /// /// A wrapper class which wraps all the events contained within the class. /// - public static ApplicationEvents Events(this global::Xamarin.Forms.Application item) => new ApplicationEvents(item); + public static RxApplicationEvents Events(this global::Xamarin.Forms.Application item) => new RxApplicationEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static BaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new BaseShellItemEvents(item); + public static RxBaseShellItemEvents Events(this global::Xamarin.Forms.BaseShellItem item) => new RxBaseShellItemEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static BindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new BindableObjectEvents(item); + public static RxBindableObjectEvents Events(this global::Xamarin.Forms.BindableObject item) => new RxBindableObjectEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ButtonEvents Events(this global::Xamarin.Forms.Button item) => new ButtonEvents(item); + public static RxButtonEvents Events(this global::Xamarin.Forms.Button item) => new RxButtonEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CarouselViewEvents Events(this global::Xamarin.Forms.CarouselView item) => new CarouselViewEvents(item); + public static RxCarouselViewEvents Events(this global::Xamarin.Forms.CarouselView item) => new RxCarouselViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CellEvents Events(this global::Xamarin.Forms.Cell item) => new CellEvents(item); + public static RxCellEvents Events(this global::Xamarin.Forms.Cell item) => new RxCellEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new CheckBoxEvents(item); + public static RxCheckBoxEvents Events(this global::Xamarin.Forms.CheckBox item) => new RxCheckBoxEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new ChildGestureRecognizerEvents(item); + public static RxChildGestureRecognizerEvents Events(this global::Xamarin.Forms.ChildGestureRecognizer item) => new RxChildGestureRecognizerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new ClickGestureRecognizerEvents(item); + public static RxClickGestureRecognizerEvents Events(this global::Xamarin.Forms.ClickGestureRecognizer item) => new RxClickGestureRecognizerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new ColumnDefinitionEvents(item); + public static RxColumnDefinitionEvents Events(this global::Xamarin.Forms.ColumnDefinition item) => new RxColumnDefinitionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static CommandEvents Events(this global::Xamarin.Forms.Command item) => new CommandEvents(item); + public static RxCommandEvents Events(this global::Xamarin.Forms.Command item) => new RxCommandEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static DatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new DatePickerEvents(item); + public static RxDatePickerEvents Events(this global::Xamarin.Forms.DatePicker item) => new RxDatePickerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDragGestureRecognizerEvents Events(this global::Xamarin.Forms.DragGestureRecognizer item) => new RxDragGestureRecognizerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxDropGestureRecognizerEvents Events(this global::Xamarin.Forms.DropGestureRecognizer item) => new RxDropGestureRecognizerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static EditorEvents Events(this global::Xamarin.Forms.Editor item) => new EditorEvents(item); + public static RxEditorEvents Events(this global::Xamarin.Forms.Editor item) => new RxEditorEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ElementEvents Events(this global::Xamarin.Forms.Element item) => new ElementEvents(item); + public static RxElementEvents Events(this global::Xamarin.Forms.Element item) => new RxElementEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static EntryEvents Events(this global::Xamarin.Forms.Entry item) => new EntryEvents(item); + public static RxEntryEvents Events(this global::Xamarin.Forms.Entry item) => new RxEntryEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static EntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new EntryCellEvents(item); + public static RxEntryCellEvents Events(this global::Xamarin.Forms.EntryCell item) => new RxEntryCellEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxExpanderEvents Events(this global::Xamarin.Forms.Expander item) => new RxExpanderEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new ICellControllerEvents(item); + public static RxICellControllerEvents Events(this global::Xamarin.Forms.ICellController item) => new RxICellControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new IDefinitionEvents(item); + public static RxIDefinitionEvents Events(this global::Xamarin.Forms.IDefinition item) => new RxIDefinitionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new IElementControllerEvents(item); + public static RxIElementControllerEvents Events(this global::Xamarin.Forms.IElementController item) => new RxIElementControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new ILayoutEvents(item); + public static RxILayoutEvents Events(this global::Xamarin.Forms.ILayout item) => new RxILayoutEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new IListProxyEvents(item); + public static RxIListProxyEvents Events(this global::Xamarin.Forms.IListProxy item) => new RxIListProxyEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new IListViewControllerEvents(item); + public static RxIListViewControllerEvents Events(this global::Xamarin.Forms.IListViewController item) => new RxIListViewControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new ImageButtonEvents(item); + public static RxImageButtonEvents Events(this global::Xamarin.Forms.ImageButton item) => new RxImageButtonEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new IMasterDetailPageControllerEvents(item); + public static RxIMasterDetailPageControllerEvents Events(this global::Xamarin.Forms.IMasterDetailPageController item) => new RxIMasterDetailPageControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static INavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new INavigationPageControllerEvents(item); + public static RxINavigationPageControllerEvents Events(this global::Xamarin.Forms.INavigationPageController item) => new RxINavigationPageControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static InputViewEvents Events(this global::Xamarin.Forms.InputView item) => new InputViewEvents(item); + public static RxInputViewEvents Events(this global::Xamarin.Forms.InputView item) => new RxInputViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new IOpenGlViewControllerEvents(item); + public static RxIOpenGlViewControllerEvents Events(this global::Xamarin.Forms.IOpenGlViewController item) => new RxIOpenGlViewControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new IScrollViewControllerEvents(item); + public static RxIScrollViewControllerEvents Events(this global::Xamarin.Forms.IScrollViewController item) => new RxIScrollViewControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new ISearchHandlerControllerEvents(item); + public static RxISearchHandlerControllerEvents Events(this global::Xamarin.Forms.ISearchHandlerController item) => new RxISearchHandlerControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIShellContentControllerEvents Events(this global::Xamarin.Forms.IShellContentController item) => new RxIShellContentControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new IShellControllerEvents(item); + public static RxIShellControllerEvents Events(this global::Xamarin.Forms.IShellController item) => new RxIShellControllerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIShellItemControllerEvents Events(this global::Xamarin.Forms.IShellItemController item) => new RxIShellItemControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new IShellSectionControllerEvents(item); + public static RxIShellSectionControllerEvents Events(this global::Xamarin.Forms.IShellSectionController item) => new RxIShellSectionControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ISwipeItemEvents Events(this global::Xamarin.Forms.ISwipeItem item) => new ISwipeItemEvents(item); + public static RxISwipeItemEvents Events(this global::Xamarin.Forms.ISwipeItem item) => new RxISwipeItemEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new ITableViewControllerEvents(item); + public static RxITableViewControllerEvents Events(this global::Xamarin.Forms.ITableViewController item) => new RxITableViewControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new ItemsViewEvents(item); + public static RxItemsViewEvents Events(this global::Xamarin.Forms.ItemsView item) => new RxItemsViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new IVisualElementControllerEvents(item); + public static RxIVisualElementControllerEvents Events(this global::Xamarin.Forms.IVisualElementController item) => new RxIVisualElementControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new IWebViewControllerEvents(item); + public static RxIWebViewControllerEvents Events(this global::Xamarin.Forms.IWebViewController item) => new RxIWebViewControllerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static LayoutEvents Events(this global::Xamarin.Forms.Layout item) => new LayoutEvents(item); + public static RxLayoutEvents Events(this global::Xamarin.Forms.Layout item) => new RxLayoutEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ListViewEvents Events(this global::Xamarin.Forms.ListView item) => new ListViewEvents(item); + public static RxListViewEvents Events(this global::Xamarin.Forms.ListView item) => new RxListViewEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMarshalingObservableCollectionEvents Events(this global::Xamarin.Forms.MarshalingObservableCollection item) => new RxMarshalingObservableCollectionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new MasterDetailPageEvents(item); + public static RxMasterDetailPageEvents Events(this global::Xamarin.Forms.MasterDetailPage item) => new RxMasterDetailPageEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementEvents Events(this global::Xamarin.Forms.MediaElement item) => new RxMediaElementEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new MenuItemEvents(item); + public static RxMenuItemEvents Events(this global::Xamarin.Forms.MenuItem item) => new RxMenuItemEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static NavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new NavigationPageEvents(item); + public static RxNavigationPageEvents Events(this global::Xamarin.Forms.NavigationPage item) => new RxNavigationPageEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static OpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new OpenGLViewEvents(item); + public static RxOpenGLViewEvents Events(this global::Xamarin.Forms.OpenGLView item) => new RxOpenGLViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PageEvents Events(this global::Xamarin.Forms.Page item) => new PageEvents(item); + public static RxPageEvents Events(this global::Xamarin.Forms.Page item) => new RxPageEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new PanGestureRecognizerEvents(item); + public static RxPanGestureRecognizerEvents Events(this global::Xamarin.Forms.PanGestureRecognizer item) => new RxPanGestureRecognizerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PickerEvents Events(this global::Xamarin.Forms.Picker item) => new PickerEvents(item); + public static RxPickerEvents Events(this global::Xamarin.Forms.Picker item) => new RxPickerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static PinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new PinchGestureRecognizerEvents(item); + public static RxPinchGestureRecognizerEvents Events(this global::Xamarin.Forms.PinchGestureRecognizer item) => new RxPinchGestureRecognizerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonEvents Events(this global::Xamarin.Forms.RadioButton item) => new RxRadioButtonEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RefreshViewEvents Events(this global::Xamarin.Forms.RefreshView item) => new RefreshViewEvents(item); + public static RxRefreshViewEvents Events(this global::Xamarin.Forms.RefreshView item) => new RxRefreshViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RowDefinitionEvents(item); + public static RxRowDefinitionEvents Events(this global::Xamarin.Forms.RowDefinition item) => new RxRowDefinitionEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new ScrollViewEvents(item); + public static RxScrollViewEvents Events(this global::Xamarin.Forms.ScrollView item) => new RxScrollViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new SearchBarEvents(item); + public static RxSearchBarEvents Events(this global::Xamarin.Forms.SearchBar item) => new RxSearchBarEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new SearchHandlerEvents(item); + public static RxSearchHandlerEvents Events(this global::Xamarin.Forms.SearchHandler item) => new RxSearchHandlerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new SelectableItemsViewEvents(item); + public static RxSelectableItemsViewEvents Events(this global::Xamarin.Forms.SelectableItemsView item) => new RxSelectableItemsViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ShellEvents Events(this global::Xamarin.Forms.Shell item) => new ShellEvents(item); + public static RxShellEvents Events(this global::Xamarin.Forms.Shell item) => new RxShellEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SliderEvents Events(this global::Xamarin.Forms.Slider item) => new SliderEvents(item); + public static RxSliderEvents Events(this global::Xamarin.Forms.Slider item) => new RxSliderEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxStateTriggerBaseEvents Events(this global::Xamarin.Forms.StateTriggerBase item) => new RxStateTriggerBaseEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static StepperEvents Events(this global::Xamarin.Forms.Stepper item) => new StepperEvents(item); + public static RxStepperEvents Events(this global::Xamarin.Forms.Stepper item) => new RxStepperEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new SwipeGestureRecognizerEvents(item); + public static RxSwipeGestureRecognizerEvents Events(this global::Xamarin.Forms.SwipeGestureRecognizer item) => new RxSwipeGestureRecognizerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SwipeItemEvents Events(this global::Xamarin.Forms.SwipeItem item) => new SwipeItemEvents(item); + public static RxSwipeItemEvents Events(this global::Xamarin.Forms.SwipeItem item) => new RxSwipeItemEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SwipeItemsEvents Events(this global::Xamarin.Forms.SwipeItems item) => new SwipeItemsEvents(item); + public static RxSwipeItemsEvents Events(this global::Xamarin.Forms.SwipeItems item) => new RxSwipeItemsEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SwipeItemViewEvents Events(this global::Xamarin.Forms.SwipeItemView item) => new SwipeItemViewEvents(item); + public static RxSwipeItemViewEvents Events(this global::Xamarin.Forms.SwipeItemView item) => new RxSwipeItemViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SwipeViewEvents Events(this global::Xamarin.Forms.SwipeView item) => new SwipeViewEvents(item); + public static RxSwipeViewEvents Events(this global::Xamarin.Forms.SwipeView item) => new RxSwipeViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SwitchEvents Events(this global::Xamarin.Forms.Switch item) => new SwitchEvents(item); + public static RxSwitchEvents Events(this global::Xamarin.Forms.Switch item) => new RxSwitchEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new SwitchCellEvents(item); + public static RxSwitchCellEvents Events(this global::Xamarin.Forms.SwitchCell item) => new RxSwitchCellEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TableViewEvents Events(this global::Xamarin.Forms.TableView item) => new TableViewEvents(item); + public static RxTableViewEvents Events(this global::Xamarin.Forms.TableView item) => new RxTableViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new TapGestureRecognizerEvents(item); + public static RxTapGestureRecognizerEvents Events(this global::Xamarin.Forms.TapGestureRecognizer item) => new RxTapGestureRecognizerEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new ToolbarItemEvents(item); + public static RxToolbarItemEvents Events(this global::Xamarin.Forms.ToolbarItem item) => new RxToolbarItemEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static VisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new VisualElementEvents(item); + public static RxVisualElementEvents Events(this global::Xamarin.Forms.VisualElement item) => new RxVisualElementEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static WebViewEvents Events(this global::Xamarin.Forms.WebView item) => new WebViewEvents(item); + public static RxWebViewEvents Events(this global::Xamarin.Forms.WebView item) => new RxWebViewEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ApplicationEvents : global::Xamarin.Forms.ElementEvents + public class RxApplicationEvents : global::Xamarin.Forms.RxElementEvents { private readonly global::Xamarin.Forms.Application _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ApplicationEvents(global::Xamarin.Forms.Application data): base(data) + public RxApplicationEvents(global::Xamarin.Forms.Application data): base(data) { _data = data; } @@ -810,9 +801,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); + }, x => _data.ModalPopped += x, x => _data.ModalPopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -820,9 +809,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); + }, x => _data.ModalPopping += x, x => _data.ModalPopping -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -830,9 +817,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); + }, x => _data.ModalPushed += x, x => _data.ModalPushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -840,9 +825,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); + }, x => _data.ModalPushing += x, x => _data.ModalPushing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -850,9 +833,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); + }, x => _data.PageAppearing += x, x => _data.PageAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -860,22 +841,28 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); + }, x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable RequestedThemeChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.AppThemeChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Xamarin.Forms.AppThemeChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.RequestedThemeChanged += x, x => _data.RequestedThemeChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class BaseShellItemEvents : global::Xamarin.Forms.ElementEvents + public class RxBaseShellItemEvents : global::Xamarin.Forms.RxElementEvents { private readonly global::Xamarin.Forms.BaseShellItem _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) + public RxBaseShellItemEvents(global::Xamarin.Forms.BaseShellItem data): base(data) { _data = data; } @@ -887,9 +874,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -897,22 +882,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class BindableObjectEvents + public class RxBindableObjectEvents { private readonly global::Xamarin.Forms.BindableObject _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public BindableObjectEvents(global::Xamarin.Forms.BindableObject data) + public RxBindableObjectEvents(global::Xamarin.Forms.BindableObject data) { _data = data; } @@ -924,9 +907,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -934,9 +915,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -944,22 +923,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); + }, x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ButtonEvents : global::Xamarin.Forms.VisualElementEvents + public class RxButtonEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.Button _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ButtonEvents(global::Xamarin.Forms.Button data): base(data) + public RxButtonEvents(global::Xamarin.Forms.Button data): base(data) { _data = data; } @@ -971,9 +948,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -981,9 +956,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -991,22 +964,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CarouselViewEvents : global::Xamarin.Forms.ItemsViewEvents + public class RxCarouselViewEvents : global::Xamarin.Forms.RxItemsViewEvents { private readonly global::Xamarin.Forms.CarouselView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CarouselViewEvents(global::Xamarin.Forms.CarouselView data): base(data) + public RxCarouselViewEvents(global::Xamarin.Forms.CarouselView data): base(data) { _data = data; } @@ -1018,9 +989,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1028,22 +997,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CellEvents : global::Xamarin.Forms.ElementEvents + public class RxCellEvents : global::Xamarin.Forms.RxElementEvents { private readonly global::Xamarin.Forms.Cell _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CellEvents(global::Xamarin.Forms.Cell data): base(data) + public RxCellEvents(global::Xamarin.Forms.Cell data): base(data) { _data = data; } @@ -1055,9 +1022,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1065,9 +1030,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1075,9 +1038,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1085,22 +1046,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CheckBoxEvents : global::Xamarin.Forms.VisualElementEvents + public class RxCheckBoxEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.CheckBox _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) + public RxCheckBoxEvents(global::Xamarin.Forms.CheckBox data): base(data) { _data = data; } @@ -1112,22 +1071,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ChildGestureRecognizerEvents + public class RxChildGestureRecognizerEvents { private readonly global::Xamarin.Forms.ChildGestureRecognizer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) + public RxChildGestureRecognizerEvents(global::Xamarin.Forms.ChildGestureRecognizer data) { _data = data; } @@ -1139,22 +1096,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ClickGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents + public class RxClickGestureRecognizerEvents : global::Xamarin.Forms.RxElementEvents { private readonly global::Xamarin.Forms.ClickGestureRecognizer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) + public RxClickGestureRecognizerEvents(global::Xamarin.Forms.ClickGestureRecognizer data): base(data) { _data = data; } @@ -1166,22 +1121,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ColumnDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents + public class RxColumnDefinitionEvents : global::Xamarin.Forms.RxBindableObjectEvents { private readonly global::Xamarin.Forms.ColumnDefinition _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) + public RxColumnDefinitionEvents(global::Xamarin.Forms.ColumnDefinition data): base(data) { _data = data; } @@ -1193,22 +1146,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class CommandEvents + public class RxCommandEvents { private readonly global::Xamarin.Forms.Command _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CommandEvents(global::Xamarin.Forms.Command data) + public RxCommandEvents(global::Xamarin.Forms.Command data) { _data = data; } @@ -1220,22 +1171,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class DatePickerEvents : global::Xamarin.Forms.VisualElementEvents + public class RxDatePickerEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.DatePicker _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) + public RxDatePickerEvents(global::Xamarin.Forms.DatePicker data): base(data) { _data = data; } @@ -1247,22 +1196,86 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); return Handler; + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDragGestureRecognizerEvents : global::Xamarin.Forms.RxElementEvents + { + private readonly global::Xamarin.Forms.DragGestureRecognizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDragGestureRecognizerEvents(global::Xamarin.Forms.DragGestureRecognizer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragStarting => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DragStartingEventArgs>(eventHandler => + { + void Handler(object sender, global::Xamarin.Forms.DragStartingEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragStarting += x, x => _data.DragStarting -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DropCompleted => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DropCompletedEventArgs>(eventHandler => + { + void Handler(object sender, global::Xamarin.Forms.DropCompletedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DropCompleted += x, x => _data.DropCompleted -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxDropGestureRecognizerEvents : global::Xamarin.Forms.RxElementEvents + { + private readonly global::Xamarin.Forms.DropGestureRecognizer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxDropGestureRecognizerEvents(global::Xamarin.Forms.DropGestureRecognizer data): base(data) + { + _data = data; } - , x => _data.DateSelected += x, x => _data.DateSelected -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable DragOver => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DragEventArgs>(eventHandler => + { + void Handler(object sender, global::Xamarin.Forms.DragEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.DragOver += x, x => _data.DragOver -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Drop => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.DropEventArgs>(eventHandler => + { + void Handler(object sender, global::Xamarin.Forms.DropEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Drop += x, x => _data.Drop -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class EditorEvents : global::Xamarin.Forms.InputViewEvents + public class RxEditorEvents : global::Xamarin.Forms.RxInputViewEvents { private readonly global::Xamarin.Forms.Editor _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public EditorEvents(global::Xamarin.Forms.Editor data): base(data) + public RxEditorEvents(global::Xamarin.Forms.Editor data): base(data) { _data = data; } @@ -1274,22 +1287,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ElementEvents : global::Xamarin.Forms.BindableObjectEvents + public class RxElementEvents : global::Xamarin.Forms.RxBindableObjectEvents { private readonly global::Xamarin.Forms.Element _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ElementEvents(global::Xamarin.Forms.Element data): base(data) + public RxElementEvents(global::Xamarin.Forms.Element data): base(data) { _data = data; } @@ -1301,9 +1312,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); + }, x => _data.ChildAdded += x, x => _data.ChildAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1311,9 +1320,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); + }, x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1321,9 +1328,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); + }, x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1331,9 +1336,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); + }, x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1342,22 +1345,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class EntryEvents : global::Xamarin.Forms.InputViewEvents + public class RxEntryEvents : global::Xamarin.Forms.RxInputViewEvents { private readonly global::Xamarin.Forms.Entry _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public EntryEvents(global::Xamarin.Forms.Entry data): base(data) + public RxEntryEvents(global::Xamarin.Forms.Entry data): base(data) { _data = data; } @@ -1369,22 +1370,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class EntryCellEvents : global::Xamarin.Forms.CellEvents + public class RxEntryCellEvents : global::Xamarin.Forms.RxCellEvents { private readonly global::Xamarin.Forms.EntryCell _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public EntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) + public RxEntryCellEvents(global::Xamarin.Forms.EntryCell data): base(data) { _data = data; } @@ -1396,22 +1395,45 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; + }, x => _data.Completed += x, x => _data.Completed -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxExpanderEvents : global::Xamarin.Forms.RxLayoutEvents + { + private readonly global::Xamarin.Forms.Expander _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxExpanderEvents(global::Xamarin.Forms.Expander data): base(data) + { + _data = data; } - , x => _data.Completed += x, x => _data.Completed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable Tapped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ICellControllerEvents + public class RxICellControllerEvents { private readonly global::Xamarin.Forms.ICellController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ICellControllerEvents(global::Xamarin.Forms.ICellController data) + public RxICellControllerEvents(global::Xamarin.Forms.ICellController data) { _data = data; } @@ -1423,22 +1445,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IDefinitionEvents + public class RxIDefinitionEvents { private readonly global::Xamarin.Forms.IDefinition _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IDefinitionEvents(global::Xamarin.Forms.IDefinition data) + public RxIDefinitionEvents(global::Xamarin.Forms.IDefinition data) { _data = data; } @@ -1450,22 +1470,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IElementControllerEvents + public class RxIElementControllerEvents { private readonly global::Xamarin.Forms.IElementController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IElementControllerEvents(global::Xamarin.Forms.IElementController data) + public RxIElementControllerEvents(global::Xamarin.Forms.IElementController data) { _data = data; } @@ -1478,22 +1496,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ILayoutEvents + public class RxILayoutEvents { private readonly global::Xamarin.Forms.ILayout _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ILayoutEvents(global::Xamarin.Forms.ILayout data) + public RxILayoutEvents(global::Xamarin.Forms.ILayout data) { _data = data; } @@ -1505,22 +1521,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IListProxyEvents + public class RxIListProxyEvents { private readonly global::Xamarin.Forms.IListProxy _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IListProxyEvents(global::Xamarin.Forms.IListProxy data) + public RxIListProxyEvents(global::Xamarin.Forms.IListProxy data) { _data = data; } @@ -1532,22 +1546,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IListViewControllerEvents + public class RxIListViewControllerEvents { private readonly global::Xamarin.Forms.IListViewController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IListViewControllerEvents(global::Xamarin.Forms.IListViewController data) + public RxIListViewControllerEvents(global::Xamarin.Forms.IListViewController data) { _data = data; } @@ -1559,22 +1571,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ImageButtonEvents : global::Xamarin.Forms.VisualElementEvents + public class RxImageButtonEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.ImageButton _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) + public RxImageButtonEvents(global::Xamarin.Forms.ImageButton data): base(data) { _data = data; } @@ -1586,9 +1596,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1596,9 +1604,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1606,22 +1612,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IMasterDetailPageControllerEvents + public class RxIMasterDetailPageControllerEvents { private readonly global::Xamarin.Forms.IMasterDetailPageController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) + public RxIMasterDetailPageControllerEvents(global::Xamarin.Forms.IMasterDetailPageController data) { _data = data; } @@ -1633,22 +1637,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class INavigationPageControllerEvents + public class RxINavigationPageControllerEvents { private readonly global::Xamarin.Forms.INavigationPageController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public INavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) + public RxINavigationPageControllerEvents(global::Xamarin.Forms.INavigationPageController data) { _data = data; } @@ -1660,9 +1662,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1670,9 +1670,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1680,9 +1678,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1690,9 +1686,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1700,22 +1694,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class InputViewEvents : global::Xamarin.Forms.VisualElementEvents + public class RxInputViewEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.InputView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public InputViewEvents(global::Xamarin.Forms.InputView data): base(data) + public RxInputViewEvents(global::Xamarin.Forms.InputView data): base(data) { _data = data; } @@ -1727,22 +1719,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IOpenGlViewControllerEvents + public class RxIOpenGlViewControllerEvents { private readonly global::Xamarin.Forms.IOpenGlViewController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) + public RxIOpenGlViewControllerEvents(global::Xamarin.Forms.IOpenGlViewController data) { _data = data; } @@ -1754,22 +1744,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IScrollViewControllerEvents + public class RxIScrollViewControllerEvents { private readonly global::Xamarin.Forms.IScrollViewController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) + public RxIScrollViewControllerEvents(global::Xamarin.Forms.IScrollViewController data) { _data = data; } @@ -1781,22 +1769,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ISearchHandlerControllerEvents + public class RxISearchHandlerControllerEvents { private readonly global::Xamarin.Forms.ISearchHandlerController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) + public RxISearchHandlerControllerEvents(global::Xamarin.Forms.ISearchHandlerController data) { _data = data; } @@ -1808,26 +1794,57 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); return Handler; + }, x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIShellContentControllerEvents + { + private readonly global::Xamarin.Forms.IShellContentController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIShellContentControllerEvents(global::Xamarin.Forms.IShellContentController data) + { + _data = data; } - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsPageVisibleChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsPageVisibleChanged += x, x => _data.IsPageVisibleChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IShellControllerEvents + public class RxIShellControllerEvents { private readonly global::Xamarin.Forms.IShellController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IShellControllerEvents(global::Xamarin.Forms.IShellController data) + public RxIShellControllerEvents(global::Xamarin.Forms.IShellController data) { _data = data; } + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsCollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1835,26 +1852,57 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; + }, x => _data.StructureChanged += x, x => _data.StructureChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIShellItemControllerEvents + { + private readonly global::Xamarin.Forms.IShellItemController _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIShellItemControllerEvents(global::Xamarin.Forms.IShellItemController data) + { + _data = data; } - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsCollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IShellSectionControllerEvents + public class RxIShellSectionControllerEvents { private readonly global::Xamarin.Forms.IShellSectionController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) + public RxIShellSectionControllerEvents(global::Xamarin.Forms.IShellSectionController data) { _data = data; } + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ItemsCollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1862,22 +1910,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); + }, x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ISwipeItemEvents + public class RxISwipeItemEvents { private readonly global::Xamarin.Forms.ISwipeItem _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ISwipeItemEvents(global::Xamarin.Forms.ISwipeItem data) + public RxISwipeItemEvents(global::Xamarin.Forms.ISwipeItem data) { _data = data; } @@ -1889,22 +1935,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ITableViewControllerEvents + public class RxITableViewControllerEvents { private readonly global::Xamarin.Forms.ITableViewController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) + public RxITableViewControllerEvents(global::Xamarin.Forms.ITableViewController data) { _data = data; } @@ -1916,22 +1960,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ItemsViewEvents : global::Xamarin.Forms.VisualElementEvents + public class RxItemsViewEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.ItemsView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) + public RxItemsViewEvents(global::Xamarin.Forms.ItemsView data): base(data) { _data = data; } @@ -1943,9 +1985,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); + }, x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1953,9 +1993,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1963,22 +2001,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IVisualElementControllerEvents + public class RxIVisualElementControllerEvents { private readonly global::Xamarin.Forms.IVisualElementController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) + public RxIVisualElementControllerEvents(global::Xamarin.Forms.IVisualElementController data) { _data = data; } @@ -1990,9 +2026,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2000,22 +2034,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IWebViewControllerEvents + public class RxIWebViewControllerEvents { private readonly global::Xamarin.Forms.IWebViewController _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) + public RxIWebViewControllerEvents(global::Xamarin.Forms.IWebViewController data) { _data = data; } @@ -2027,9 +2059,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2037,9 +2067,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2047,9 +2075,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2057,22 +2083,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class LayoutEvents : global::Xamarin.Forms.VisualElementEvents + public class RxLayoutEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.Layout _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public LayoutEvents(global::Xamarin.Forms.Layout data): base(data) + public RxLayoutEvents(global::Xamarin.Forms.Layout data): base(data) { _data = data; } @@ -2084,22 +2108,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ListViewEvents : global::Xamarin.Forms.VisualElementEvents + public class RxListViewEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.ListView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ListViewEvents(global::Xamarin.Forms.ListView data): base(data) + public RxListViewEvents(global::Xamarin.Forms.ListView data): base(data) { _data = data; } @@ -2111,9 +2133,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); + }, x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2121,9 +2141,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); + }, x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2131,9 +2149,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2141,9 +2157,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); + }, x => _data.ItemTapped += x, x => _data.ItemTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2151,9 +2165,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2161,9 +2173,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2171,22 +2181,45 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMarshalingObservableCollectionEvents + { + private readonly global::Xamarin.Forms.MarshalingObservableCollection _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMarshalingObservableCollectionEvents(global::Xamarin.Forms.MarshalingObservableCollection data) + { + _data = data; } - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CollectionChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MasterDetailPageEvents : global::Xamarin.Forms.PageEvents + public class RxMasterDetailPageEvents : global::Xamarin.Forms.RxPageEvents { private readonly global::Xamarin.Forms.MasterDetailPage _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) + public RxMasterDetailPageEvents(global::Xamarin.Forms.MasterDetailPage data): base(data) { _data = data; } @@ -2198,9 +2231,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2208,22 +2239,101 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementEvents : global::Xamarin.Forms.RxVisualElementEvents + { + private readonly global::Xamarin.Forms.MediaElement _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementEvents(global::Xamarin.Forms.MediaElement data): base(data) + { + _data = data; } - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaEnded => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaFailed => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable MediaOpened => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PositionRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PositionRequested += x, x => _data.PositionRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SeekCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable SeekRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SeekRequested>(eventHandler => + { + void Handler(object sender, global::Xamarin.Forms.SeekRequested e) => eventHandler(e); + return Handler; + }, x => _data.SeekRequested += x, x => _data.SeekRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable StateRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.StateRequested>(eventHandler => + { + void Handler(object sender, global::Xamarin.Forms.StateRequested e) => eventHandler(e); + return Handler; + }, x => _data.StateRequested += x, x => _data.StateRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable VolumeRequested => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.VolumeRequested += x, x => _data.VolumeRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MenuItemEvents : global::Xamarin.Forms.ElementEvents + public class RxMenuItemEvents : global::Xamarin.Forms.RxElementEvents { private readonly global::Xamarin.Forms.MenuItem _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) + public RxMenuItemEvents(global::Xamarin.Forms.MenuItem data): base(data) { _data = data; } @@ -2235,22 +2345,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class NavigationPageEvents : global::Xamarin.Forms.PageEvents + public class RxNavigationPageEvents : global::Xamarin.Forms.RxPageEvents { private readonly global::Xamarin.Forms.NavigationPage _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public NavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) + public RxNavigationPageEvents(global::Xamarin.Forms.NavigationPage data): base(data) { _data = data; } @@ -2262,9 +2370,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2272,9 +2378,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2282,9 +2386,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); + }, x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2292,9 +2394,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2302,9 +2402,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2312,9 +2410,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); + }, x => _data.Pushed += x, x => _data.Pushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2322,9 +2418,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2332,22 +2426,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class OpenGLViewEvents : global::Xamarin.Forms.VisualElementEvents + public class RxOpenGLViewEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.OpenGLView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public OpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) + public RxOpenGLViewEvents(global::Xamarin.Forms.OpenGLView data): base(data) { _data = data; } @@ -2359,22 +2451,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PageEvents : global::Xamarin.Forms.VisualElementEvents + public class RxPageEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.Page _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PageEvents(global::Xamarin.Forms.Page data): base(data) + public RxPageEvents(global::Xamarin.Forms.Page data): base(data) { _data = data; } @@ -2386,9 +2476,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2396,9 +2484,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2406,22 +2492,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PanGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents + public class RxPanGestureRecognizerEvents : global::Xamarin.Forms.RxElementEvents { private readonly global::Xamarin.Forms.PanGestureRecognizer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) + public RxPanGestureRecognizerEvents(global::Xamarin.Forms.PanGestureRecognizer data): base(data) { _data = data; } @@ -2433,22 +2517,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); + }, x => _data.PanUpdated += x, x => _data.PanUpdated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PickerEvents : global::Xamarin.Forms.VisualElementEvents + public class RxPickerEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.Picker _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PickerEvents(global::Xamarin.Forms.Picker data): base(data) + public RxPickerEvents(global::Xamarin.Forms.Picker data): base(data) { _data = data; } @@ -2460,22 +2542,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class PinchGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents + public class RxPinchGestureRecognizerEvents : global::Xamarin.Forms.RxElementEvents { private readonly global::Xamarin.Forms.PinchGestureRecognizer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public PinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) + public RxPinchGestureRecognizerEvents(global::Xamarin.Forms.PinchGestureRecognizer data): base(data) { _data = data; } @@ -2487,22 +2567,45 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); return Handler; + }, x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonEvents : global::Xamarin.Forms.RxButtonEvents + { + private readonly global::Xamarin.Forms.RadioButton _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonEvents(global::Xamarin.Forms.RadioButton data): base(data) + { + _data = data; } - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable CheckedChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.CheckedChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RefreshViewEvents : global::Xamarin.Forms.LayoutEvents + public class RxRefreshViewEvents : global::Xamarin.Forms.RxLayoutEvents { private readonly global::Xamarin.Forms.RefreshView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RefreshViewEvents(global::Xamarin.Forms.RefreshView data): base(data) + public RxRefreshViewEvents(global::Xamarin.Forms.RefreshView data): base(data) { _data = data; } @@ -2514,22 +2617,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RowDefinitionEvents : global::Xamarin.Forms.BindableObjectEvents + public class RxRowDefinitionEvents : global::Xamarin.Forms.RxBindableObjectEvents { private readonly global::Xamarin.Forms.RowDefinition _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) + public RxRowDefinitionEvents(global::Xamarin.Forms.RowDefinition data): base(data) { _data = data; } @@ -2541,22 +2642,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ScrollViewEvents : global::Xamarin.Forms.LayoutEvents + public class RxScrollViewEvents : global::Xamarin.Forms.RxLayoutEvents { private readonly global::Xamarin.Forms.ScrollView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) + public RxScrollViewEvents(global::Xamarin.Forms.ScrollView data): base(data) { _data = data; } @@ -2568,9 +2667,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2578,22 +2675,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SearchBarEvents : global::Xamarin.Forms.InputViewEvents + public class RxSearchBarEvents : global::Xamarin.Forms.RxInputViewEvents { private readonly global::Xamarin.Forms.SearchBar _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) + public RxSearchBarEvents(global::Xamarin.Forms.SearchBar data): base(data) { _data = data; } @@ -2605,22 +2700,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); + }, x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SearchHandlerEvents : global::Xamarin.Forms.BindableObjectEvents + public class RxSearchHandlerEvents : global::Xamarin.Forms.RxBindableObjectEvents { private readonly global::Xamarin.Forms.SearchHandler _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) + public RxSearchHandlerEvents(global::Xamarin.Forms.SearchHandler data): base(data) { _data = data; } @@ -2632,9 +2725,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2642,9 +2733,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2652,22 +2741,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SelectableItemsViewEvents : global::Xamarin.Forms.ItemsViewEvents + public class RxSelectableItemsViewEvents : global::Xamarin.Forms.RxItemsViewEvents { private readonly global::Xamarin.Forms.SelectableItemsView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) + public RxSelectableItemsViewEvents(global::Xamarin.Forms.SelectableItemsView data): base(data) { _data = data; } @@ -2679,22 +2766,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ShellEvents : global::Xamarin.Forms.PageEvents + public class RxShellEvents : global::Xamarin.Forms.RxPageEvents { private readonly global::Xamarin.Forms.Shell _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ShellEvents(global::Xamarin.Forms.Shell data): base(data) + public RxShellEvents(global::Xamarin.Forms.Shell data): base(data) { _data = data; } @@ -2706,9 +2791,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2716,22 +2799,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SliderEvents : global::Xamarin.Forms.VisualElementEvents + public class RxSliderEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.Slider _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SliderEvents(global::Xamarin.Forms.Slider data): base(data) + public RxSliderEvents(global::Xamarin.Forms.Slider data): base(data) { _data = data; } @@ -2743,9 +2824,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2753,9 +2832,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2763,22 +2840,45 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxStateTriggerBaseEvents : global::Xamarin.Forms.RxBindableObjectEvents + { + private readonly global::Xamarin.Forms.StateTriggerBase _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxStateTriggerBaseEvents(global::Xamarin.Forms.StateTriggerBase data): base(data) + { + _data = data; } - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable IsActiveChanged => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.IsActiveChanged += x, x => _data.IsActiveChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class StepperEvents : global::Xamarin.Forms.VisualElementEvents + public class RxStepperEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.Stepper _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public StepperEvents(global::Xamarin.Forms.Stepper data): base(data) + public RxStepperEvents(global::Xamarin.Forms.Stepper data): base(data) { _data = data; } @@ -2790,22 +2890,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SwipeGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents + public class RxSwipeGestureRecognizerEvents : global::Xamarin.Forms.RxElementEvents { private readonly global::Xamarin.Forms.SwipeGestureRecognizer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) + public RxSwipeGestureRecognizerEvents(global::Xamarin.Forms.SwipeGestureRecognizer data): base(data) { _data = data; } @@ -2817,22 +2915,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); + }, x => _data.Swiped += x, x => _data.Swiped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SwipeItemEvents : global::Xamarin.Forms.MenuItemEvents + public class RxSwipeItemEvents : global::Xamarin.Forms.RxMenuItemEvents { private readonly global::Xamarin.Forms.SwipeItem _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SwipeItemEvents(global::Xamarin.Forms.SwipeItem data): base(data) + public RxSwipeItemEvents(global::Xamarin.Forms.SwipeItem data): base(data) { _data = data; } @@ -2844,22 +2940,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SwipeItemsEvents : global::Xamarin.Forms.ElementEvents + public class RxSwipeItemsEvents : global::Xamarin.Forms.RxElementEvents { private readonly global::Xamarin.Forms.SwipeItems _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SwipeItemsEvents(global::Xamarin.Forms.SwipeItems data): base(data) + public RxSwipeItemsEvents(global::Xamarin.Forms.SwipeItems data): base(data) { _data = data; } @@ -2871,22 +2965,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SwipeItemViewEvents : global::Xamarin.Forms.LayoutEvents + public class RxSwipeItemViewEvents : global::Xamarin.Forms.RxLayoutEvents { private readonly global::Xamarin.Forms.SwipeItemView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SwipeItemViewEvents(global::Xamarin.Forms.SwipeItemView data): base(data) + public RxSwipeItemViewEvents(global::Xamarin.Forms.SwipeItemView data): base(data) { _data = data; } @@ -2898,22 +2990,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SwipeViewEvents : global::Xamarin.Forms.LayoutEvents + public class RxSwipeViewEvents : global::Xamarin.Forms.RxLayoutEvents { private readonly global::Xamarin.Forms.SwipeView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SwipeViewEvents(global::Xamarin.Forms.SwipeView data): base(data) + public RxSwipeViewEvents(global::Xamarin.Forms.SwipeView data): base(data) { _data = data; } @@ -2925,19 +3015,23 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable OpenRequested => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.OpenSwipeEventArgs>(eventHandler => + { + void Handler(object sender, global::Xamarin.Forms.OpenSwipeEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.OpenRequested += x, x => _data.OpenRequested -= x); /// /// Gets an observable which signals when the event triggers. /// public global::System.IObservable SwipeChanging => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.SwipeChangingEventArgs>(eventHandler => { void Handler(object sender, global::Xamarin.Forms.SwipeChangingEventArgs e) => eventHandler(e); - return Handler; - } - - , x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); + return Handler; + }, x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2945,9 +3039,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeEndedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); + }, x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2955,22 +3047,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); + }, x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SwitchEvents : global::Xamarin.Forms.VisualElementEvents + public class RxSwitchEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.Switch _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SwitchEvents(global::Xamarin.Forms.Switch data): base(data) + public RxSwitchEvents(global::Xamarin.Forms.Switch data): base(data) { _data = data; } @@ -2982,22 +3072,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SwitchCellEvents : global::Xamarin.Forms.CellEvents + public class RxSwitchCellEvents : global::Xamarin.Forms.RxCellEvents { private readonly global::Xamarin.Forms.SwitchCell _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) + public RxSwitchCellEvents(global::Xamarin.Forms.SwitchCell data): base(data) { _data = data; } @@ -3009,22 +3097,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); + }, x => _data.OnChanged += x, x => _data.OnChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TableViewEvents : global::Xamarin.Forms.VisualElementEvents + public class RxTableViewEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.TableView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TableViewEvents(global::Xamarin.Forms.TableView data): base(data) + public RxTableViewEvents(global::Xamarin.Forms.TableView data): base(data) { _data = data; } @@ -3036,22 +3122,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TapGestureRecognizerEvents : global::Xamarin.Forms.ElementEvents + public class RxTapGestureRecognizerEvents : global::Xamarin.Forms.RxElementEvents { private readonly global::Xamarin.Forms.TapGestureRecognizer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) + public RxTapGestureRecognizerEvents(global::Xamarin.Forms.TapGestureRecognizer data): base(data) { _data = data; } @@ -3063,22 +3147,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ToolbarItemEvents : global::Xamarin.Forms.MenuItemEvents + public class RxToolbarItemEvents : global::Xamarin.Forms.RxMenuItemEvents { private readonly global::Xamarin.Forms.ToolbarItem _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) + public RxToolbarItemEvents(global::Xamarin.Forms.ToolbarItem data): base(data) { _data = data; } @@ -3091,22 +3173,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class VisualElementEvents : global::Xamarin.Forms.ElementEvents + public class RxVisualElementEvents : global::Xamarin.Forms.RxElementEvents { private readonly global::Xamarin.Forms.VisualElement _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public VisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) + public RxVisualElementEvents(global::Xamarin.Forms.VisualElement data): base(data) { _data = data; } @@ -3118,9 +3198,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3128,9 +3206,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); + }, x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3138,9 +3214,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3148,9 +3222,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3158,9 +3230,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3168,9 +3238,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3178,22 +3246,20 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class WebViewEvents : global::Xamarin.Forms.VisualElementEvents + public class RxWebViewEvents : global::Xamarin.Forms.RxVisualElementEvents { private readonly global::Xamarin.Forms.WebView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public WebViewEvents(global::Xamarin.Forms.WebView data): base(data) + public RxWebViewEvents(global::Xamarin.Forms.WebView data): base(data) { _data = data; } @@ -3205,9 +3271,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3215,9 +3279,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3225,9 +3287,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3235,9 +3295,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3245,9 +3303,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3255,9 +3311,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } } @@ -3271,32 +3325,32 @@ namespace Xamarin.Forms.Internals /// /// A wrapper class which wraps all the events contained within the class. /// - public static DeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new DeviceInfoEvents(item); + public static RxDeviceInfoEvents Events(this global::Xamarin.Forms.Internals.DeviceInfo item) => new RxDeviceInfoEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new IResourceDictionaryEvents(item); + public static RxIResourceDictionaryEvents Events(this global::Xamarin.Forms.Internals.IResourceDictionary item) => new RxIResourceDictionaryEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static TableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new TableModelEvents(item); + public static RxTableModelEvents Events(this global::Xamarin.Forms.Internals.TableModel item) => new RxTableModelEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new ToolbarTrackerEvents(item); + public static RxToolbarTrackerEvents Events(this global::Xamarin.Forms.Internals.ToolbarTracker item) => new RxToolbarTrackerEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class DeviceInfoEvents + public class RxDeviceInfoEvents { private readonly global::Xamarin.Forms.Internals.DeviceInfo _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public DeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) + public RxDeviceInfoEvents(global::Xamarin.Forms.Internals.DeviceInfo data) { _data = data; } @@ -3308,22 +3362,20 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IResourceDictionaryEvents + public class RxIResourceDictionaryEvents { private readonly global::Xamarin.Forms.Internals.IResourceDictionary _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) + public RxIResourceDictionaryEvents(global::Xamarin.Forms.Internals.IResourceDictionary data) { _data = data; } @@ -3335,22 +3387,20 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); + }, x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class TableModelEvents + public class RxTableModelEvents { private readonly global::Xamarin.Forms.Internals.TableModel _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public TableModelEvents(global::Xamarin.Forms.Internals.TableModel data) + public RxTableModelEvents(global::Xamarin.Forms.Internals.TableModel data) { _data = data; } @@ -3362,9 +3412,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3372,22 +3420,20 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ToolbarTrackerEvents + public class RxToolbarTrackerEvents { private readonly global::Xamarin.Forms.Internals.ToolbarTracker _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) + public RxToolbarTrackerEvents(global::Xamarin.Forms.Internals.ToolbarTracker data) { _data = data; } @@ -3399,9 +3445,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } } @@ -3415,104 +3459,112 @@ namespace Xamarin.Forms.Platform.Android /// /// A wrapper class which wraps all the events contained within the class. /// - public static CheckBoxRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase item) => new CheckBoxRendererBaseEvents(item); + public static RxCheckBoxRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase item) => new RxCheckBoxRendererBaseEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static FormsAnimationDrawableEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAnimationDrawable item) => new FormsAnimationDrawableEvents(item); + public static RxFormsAnimationDrawableEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAnimationDrawable item) => new RxFormsAnimationDrawableEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static FormsAppCompatActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity item) => new FormsAppCompatActivityEvents(item); + public static RxFormsAppCompatActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity item) => new RxFormsAppCompatActivityEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static FormsApplicationActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsApplicationActivity item) => new FormsApplicationActivityEvents(item); + public static RxFormsApplicationActivityEvents Events(this global::Xamarin.Forms.Platform.Android.FormsApplicationActivity item) => new RxFormsApplicationActivityEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IBorderVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer item) => new IBorderVisualElementRendererEvents(item); + public static RxIBorderVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer item) => new RxIBorderVisualElementRendererEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer item) => new IButtonLayoutRendererEvents(item); + public static RxIButtonLayoutRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer item) => new RxIButtonLayoutRendererEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IDeviceInfoProviderEvents Events(this global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider item) => new IDeviceInfoProviderEvents(item); + public static RxIDeviceInfoProviderEvents Events(this global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider item) => new RxIDeviceInfoProviderEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IFormsAnimationDrawableEvents Events(this global::Xamarin.Forms.Platform.Android.IFormsAnimationDrawable item) => new IFormsAnimationDrawableEvents(item); + public static RxIFormsAnimationDrawableEvents Events(this global::Xamarin.Forms.Platform.Android.IFormsAnimationDrawable item) => new RxIFormsAnimationDrawableEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ImageButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ImageButtonRenderer item) => new ImageButtonRendererEvents(item); + public static RxImageButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ImageButtonRenderer item) => new RxImageButtonRendererEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IndicatorViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IndicatorViewRenderer item) => new IndicatorViewRendererEvents(item); + public static RxIndicatorViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IndicatorViewRenderer item) => new RxIndicatorViewRendererEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IShellItemRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IShellItemRenderer item) => new IShellItemRendererEvents(item); + public static RxIShellItemRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IShellItemRenderer item) => new RxIShellItemRendererEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IShellObservableFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.IShellObservableFragment item) => new IShellObservableFragmentEvents(item); + public static RxIShellObservableFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.IShellObservableFragment item) => new RxIShellObservableFragmentEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.IShellSearchView item) => new IShellSearchViewEvents(item); + public static RxIShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.IShellSearchView item) => new RxIShellSearchViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static IVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IVisualElementRenderer item) => new IVisualElementRendererEvents(item); + public static RxIVisualElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.IVisualElementRenderer item) => new RxIVisualElementRendererEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static MasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.Android.MasterDetailRenderer item) => new MasterDetailRendererEvents(item); + public static RxMasterDetailRendererEvents Events(this global::Xamarin.Forms.Platform.Android.MasterDetailRenderer item) => new RxMasterDetailRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxMediaElementRendererEvents Events(this global::Xamarin.Forms.Platform.Android.MediaElementRenderer item) => new RxMediaElementRendererEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxRadioButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.RadioButtonRenderer item) => new RxRadioButtonRendererEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static RefreshViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.RefreshViewRenderer item) => new RefreshViewRendererEvents(item); + public static RxRefreshViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.RefreshViewRenderer item) => new RxRefreshViewRendererEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ScrollViewRenderer item) => new ScrollViewRendererEvents(item); + public static RxScrollViewRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ScrollViewRenderer item) => new RxScrollViewRendererEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static SelectableViewHolderEvents Events(this global::Xamarin.Forms.Platform.Android.SelectableViewHolder item) => new SelectableViewHolderEvents(item); + public static RxSelectableViewHolderEvents Events(this global::Xamarin.Forms.Platform.Android.SelectableViewHolder item) => new RxSelectableViewHolderEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ShellContentFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.ShellContentFragment item) => new ShellContentFragmentEvents(item); + public static RxShellContentFragmentEvents Events(this global::Xamarin.Forms.Platform.Android.ShellContentFragment item) => new RxShellContentFragmentEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ShellItemRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.ShellItemRendererBase item) => new ShellItemRendererBaseEvents(item); + public static RxShellItemRendererBaseEvents Events(this global::Xamarin.Forms.Platform.Android.ShellItemRendererBase item) => new RxShellItemRendererBaseEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSearchView item) => new ShellSearchViewEvents(item); + public static RxShellSearchViewEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSearchView item) => new RxShellSearchViewEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ShellSectionRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSectionRenderer item) => new ShellSectionRendererEvents(item); + public static RxShellSectionRendererEvents Events(this global::Xamarin.Forms.Platform.Android.ShellSectionRenderer item) => new RxShellSectionRendererEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class CheckBoxRendererBaseEvents : global::Android.Widget.CompoundButtonEvents + public class RxCheckBoxRendererBaseEvents : global::Android.Widget.RxCompoundButtonEvents { private readonly global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public CheckBoxRendererBaseEvents(global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase data): base(data) + public RxCheckBoxRendererBaseEvents(global::Xamarin.Forms.Platform.Android.CheckBoxRendererBase data): base(data) { _data = data; } @@ -3524,9 +3576,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3534,22 +3584,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class FormsAnimationDrawableEvents + public class RxFormsAnimationDrawableEvents { private readonly global::Xamarin.Forms.Platform.Android.FormsAnimationDrawable _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public FormsAnimationDrawableEvents(global::Xamarin.Forms.Platform.Android.FormsAnimationDrawable data) + public RxFormsAnimationDrawableEvents(global::Xamarin.Forms.Platform.Android.FormsAnimationDrawable data) { _data = data; } @@ -3561,9 +3609,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationStarted += x, x => _data.AnimationStarted -= x); + }, x => _data.AnimationStarted += x, x => _data.AnimationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3571,22 +3617,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.FormsAnimationDrawableStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationStopped += x, x => _data.AnimationStopped -= x); + }, x => _data.AnimationStopped += x, x => _data.AnimationStopped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class FormsAppCompatActivityEvents + public class RxFormsAppCompatActivityEvents { private readonly global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public FormsAppCompatActivityEvents(global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity data) + public RxFormsAppCompatActivityEvents(global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity data) { _data = data; } @@ -3598,22 +3642,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class FormsApplicationActivityEvents + public class RxFormsApplicationActivityEvents { private readonly global::Xamarin.Forms.Platform.Android.FormsApplicationActivity _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public FormsApplicationActivityEvents(global::Xamarin.Forms.Platform.Android.FormsApplicationActivity data) + public RxFormsApplicationActivityEvents(global::Xamarin.Forms.Platform.Android.FormsApplicationActivity data) { _data = data; } @@ -3625,22 +3667,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IBorderVisualElementRendererEvents + public class RxIBorderVisualElementRendererEvents { private readonly global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IBorderVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer data) + public RxIBorderVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IBorderVisualElementRenderer data) { _data = data; } @@ -3652,22 +3692,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IButtonLayoutRendererEvents + public class RxIButtonLayoutRendererEvents { private readonly global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer data) + public RxIButtonLayoutRendererEvents(global::Xamarin.Forms.Platform.Android.IButtonLayoutRenderer data) { _data = data; } @@ -3679,22 +3717,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IDeviceInfoProviderEvents + public class RxIDeviceInfoProviderEvents { private readonly global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IDeviceInfoProviderEvents(global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider data) + public RxIDeviceInfoProviderEvents(global::Xamarin.Forms.Platform.Android.IDeviceInfoProvider data) { _data = data; } @@ -3706,22 +3742,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IFormsAnimationDrawableEvents + public class RxIFormsAnimationDrawableEvents { private readonly global::Xamarin.Forms.Platform.Android.IFormsAnimationDrawable _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IFormsAnimationDrawableEvents(global::Xamarin.Forms.Platform.Android.IFormsAnimationDrawable data) + public RxIFormsAnimationDrawableEvents(global::Xamarin.Forms.Platform.Android.IFormsAnimationDrawable data) { _data = data; } @@ -3733,9 +3767,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationStarted += x, x => _data.AnimationStarted -= x); + }, x => _data.AnimationStarted += x, x => _data.AnimationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3743,22 +3775,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.FormsAnimationDrawableStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationStopped += x, x => _data.AnimationStopped -= x); + }, x => _data.AnimationStopped += x, x => _data.AnimationStopped -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ImageButtonRendererEvents : global::Android.Views.ViewEvents + public class RxImageButtonRendererEvents : global::Android.Views.RxViewEvents { private readonly global::Xamarin.Forms.Platform.Android.ImageButtonRenderer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ImageButtonRendererEvents(global::Xamarin.Forms.Platform.Android.ImageButtonRenderer data): base(data) + public RxImageButtonRendererEvents(global::Xamarin.Forms.Platform.Android.ImageButtonRenderer data): base(data) { _data = data; } @@ -3770,9 +3800,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3780,22 +3808,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IndicatorViewRendererEvents : global::Android.Views.ViewGroupEvents + public class RxIndicatorViewRendererEvents : global::Android.Views.RxViewGroupEvents { private readonly global::Xamarin.Forms.Platform.Android.IndicatorViewRenderer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IndicatorViewRendererEvents(global::Xamarin.Forms.Platform.Android.IndicatorViewRenderer data): base(data) + public RxIndicatorViewRendererEvents(global::Xamarin.Forms.Platform.Android.IndicatorViewRenderer data): base(data) { _data = data; } @@ -3807,9 +3833,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3817,22 +3841,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IShellItemRendererEvents + public class RxIShellItemRendererEvents { private readonly global::Xamarin.Forms.Platform.Android.IShellItemRenderer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IShellItemRendererEvents(global::Xamarin.Forms.Platform.Android.IShellItemRenderer data) + public RxIShellItemRendererEvents(global::Xamarin.Forms.Platform.Android.IShellItemRenderer data) { _data = data; } @@ -3844,22 +3866,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IShellObservableFragmentEvents + public class RxIShellObservableFragmentEvents { private readonly global::Xamarin.Forms.Platform.Android.IShellObservableFragment _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IShellObservableFragmentEvents(global::Xamarin.Forms.Platform.Android.IShellObservableFragment data) + public RxIShellObservableFragmentEvents(global::Xamarin.Forms.Platform.Android.IShellObservableFragment data) { _data = data; } @@ -3871,22 +3891,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); + }, x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IShellSearchViewEvents + public class RxIShellSearchViewEvents { private readonly global::Xamarin.Forms.Platform.Android.IShellSearchView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.IShellSearchView data) + public RxIShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.IShellSearchView data) { _data = data; } @@ -3898,22 +3916,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); + }, x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class IVisualElementRendererEvents + public class RxIVisualElementRendererEvents { private readonly global::Xamarin.Forms.Platform.Android.IVisualElementRenderer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public IVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IVisualElementRenderer data) + public RxIVisualElementRendererEvents(global::Xamarin.Forms.Platform.Android.IVisualElementRenderer data) { _data = data; } @@ -3925,9 +3941,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3935,22 +3949,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class MasterDetailRendererEvents : global::Android.Support.V4.Widget.DrawerLayoutEvents + public class RxMasterDetailRendererEvents : global::AndroidX.DrawerLayout.Widget.RxDrawerLayoutEvents { private readonly global::Xamarin.Forms.Platform.Android.MasterDetailRenderer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public MasterDetailRendererEvents(global::Xamarin.Forms.Platform.Android.MasterDetailRenderer data): base(data) + public RxMasterDetailRendererEvents(global::Xamarin.Forms.Platform.Android.MasterDetailRenderer data): base(data) { _data = data; } @@ -3962,22 +3974,86 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxMediaElementRendererEvents : global::Android.Views.RxViewGroupEvents + { + private readonly global::Xamarin.Forms.Platform.Android.MediaElementRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxMediaElementRendererEvents(global::Xamarin.Forms.Platform.Android.MediaElementRenderer data): base(data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxRadioButtonRendererEvents : global::Android.Widget.RxCompoundButtonEvents + { + private readonly global::Xamarin.Forms.Platform.Android.RadioButtonRenderer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxRadioButtonRendererEvents(global::Xamarin.Forms.Platform.Android.RadioButtonRenderer data): base(data) + { + _data = data; } - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ElementChanged => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ElementPropertyChanged => global::System.Reactive.Linq.Observable.FromEvent, global::System.ComponentModel.PropertyChangedEventArgs>(eventHandler => + { + void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class RefreshViewRendererEvents : global::Android.Support.V4.Widget.SwipeRefreshLayoutEvents + public class RxRefreshViewRendererEvents : global::AndroidX.SwipeRefreshLayout.Widget.RxSwipeRefreshLayoutEvents { private readonly global::Xamarin.Forms.Platform.Android.RefreshViewRenderer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public RefreshViewRendererEvents(global::Xamarin.Forms.Platform.Android.RefreshViewRenderer data): base(data) + public RxRefreshViewRendererEvents(global::Xamarin.Forms.Platform.Android.RefreshViewRenderer data): base(data) { _data = data; } @@ -3989,9 +4065,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3999,22 +4073,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ScrollViewRendererEvents : global::Android.Support.V4.Widget.NestedScrollViewEvents + public class RxScrollViewRendererEvents : global::AndroidX.Core.Widget.RxNestedScrollViewEvents { private readonly global::Xamarin.Forms.Platform.Android.ScrollViewRenderer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ScrollViewRendererEvents(global::Xamarin.Forms.Platform.Android.ScrollViewRenderer data): base(data) + public RxScrollViewRendererEvents(global::Xamarin.Forms.Platform.Android.ScrollViewRenderer data): base(data) { _data = data; } @@ -4026,22 +4098,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class SelectableViewHolderEvents + public class RxSelectableViewHolderEvents { private readonly global::Xamarin.Forms.Platform.Android.SelectableViewHolder _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public SelectableViewHolderEvents(global::Xamarin.Forms.Platform.Android.SelectableViewHolder data) + public RxSelectableViewHolderEvents(global::Xamarin.Forms.Platform.Android.SelectableViewHolder data) { _data = data; } @@ -4053,22 +4123,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, int e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ShellContentFragmentEvents + public class RxShellContentFragmentEvents { private readonly global::Xamarin.Forms.Platform.Android.ShellContentFragment _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ShellContentFragmentEvents(global::Xamarin.Forms.Platform.Android.ShellContentFragment data) + public RxShellContentFragmentEvents(global::Xamarin.Forms.Platform.Android.ShellContentFragment data) { _data = data; } @@ -4080,22 +4148,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); + }, x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ShellItemRendererBaseEvents + public class RxShellItemRendererBaseEvents { private readonly global::Xamarin.Forms.Platform.Android.ShellItemRendererBase _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ShellItemRendererBaseEvents(global::Xamarin.Forms.Platform.Android.ShellItemRendererBase data) + public RxShellItemRendererBaseEvents(global::Xamarin.Forms.Platform.Android.ShellItemRendererBase data) { _data = data; } @@ -4107,22 +4173,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ShellSearchViewEvents : global::Android.Views.ViewGroupEvents + public class RxShellSearchViewEvents : global::Android.Views.RxViewGroupEvents { private readonly global::Xamarin.Forms.Platform.Android.ShellSearchView _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.ShellSearchView data): base(data) + public RxShellSearchViewEvents(global::Xamarin.Forms.Platform.Android.ShellSearchView data): base(data) { _data = data; } @@ -4134,22 +4198,20 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); + }, x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ShellSectionRendererEvents + public class RxShellSectionRendererEvents { private readonly global::Xamarin.Forms.Platform.Android.ShellSectionRenderer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ShellSectionRendererEvents(global::Xamarin.Forms.Platform.Android.ShellSectionRenderer data) + public RxShellSectionRendererEvents(global::Xamarin.Forms.Platform.Android.ShellSectionRenderer data) { _data = data; } @@ -4161,9 +4223,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); + }, x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); } } @@ -4177,32 +4237,32 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers /// /// A wrapper class which wraps all the events contained within the class. /// - public static ButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer item) => new ButtonRendererEvents(item); + public static RxButtonRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer item) => new RxButtonRendererEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static FrameRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer item) => new FrameRendererEvents(item); + public static RxFrameRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer item) => new RxFrameRendererEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static ImageRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer item) => new ImageRendererEvents(item); + public static RxImageRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer item) => new RxImageRendererEvents(item); /// /// A wrapper class which wraps all the events contained within the class. /// - public static LabelRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer item) => new LabelRendererEvents(item); + public static RxLabelRendererEvents Events(this global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer item) => new RxLabelRendererEvents(item); } /// /// A class which wraps the events contained within the class as observables. /// - public class ButtonRendererEvents : global::Android.Widget.TextViewEvents + public class RxButtonRendererEvents : global::Android.Widget.RxTextViewEvents { private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ButtonRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer data): base(data) + public RxButtonRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ButtonRenderer data): base(data) { _data = data; } @@ -4214,9 +4274,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4224,22 +4282,20 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class FrameRendererEvents : global::Android.Views.ViewGroupEvents + public class RxFrameRendererEvents : global::Android.Views.RxViewGroupEvents { private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public FrameRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer data): base(data) + public RxFrameRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.FrameRenderer data): base(data) { _data = data; } @@ -4251,9 +4307,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4261,22 +4315,20 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class ImageRendererEvents : global::Android.Views.ViewEvents + public class RxImageRendererEvents : global::Android.Views.RxViewEvents { private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public ImageRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer data): base(data) + public RxImageRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.ImageRenderer data): base(data) { _data = data; } @@ -4288,9 +4340,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4298,22 +4348,20 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// /// A class which wraps the events contained within the class as observables. /// - public class LabelRendererEvents : global::Android.Widget.TextViewEvents + public class RxLabelRendererEvents : global::Android.Widget.RxTextViewEvents { private readonly global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer _data; /// /// Initializes a new instance of the class. /// /// The class that is being wrapped. - public LabelRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer data): base(data) + public RxLabelRendererEvents(global::Xamarin.Forms.Platform.Android.FastRenderers.LabelRenderer data): base(data) { _data = data; } @@ -4325,9 +4373,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4335,9 +4381,139 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + } +} + +namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific +{ + /// + /// A class that contains extension methods to wrap events for classes contained within the namespace. + /// + public static class EventExtensions + { + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIMediaPlayerEvents Events(this global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.IMediaPlayer item) => new RxIMediaPlayerEvents(item); + /// + /// A wrapper class which wraps all the events contained within the class. + /// + public static RxIPlatformMediaPlayerEvents Events(this global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.IPlatformMediaPlayer item) => new RxIPlatformMediaPlayerEvents(item); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIMediaPlayerEvents + { + private readonly global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.IMediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIMediaPlayerEvents(global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.IMediaPlayer data) + { + _data = data; + } + + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PlaybackPaused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PlaybackStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PlaybackStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + } + + /// + /// A class which wraps the events contained within the class as observables. + /// + public class RxIPlatformMediaPlayerEvents + { + private readonly global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.IPlatformMediaPlayer _data; + /// + /// Initializes a new instance of the class. + /// + /// The class that is being wrapped. + public RxIPlatformMediaPlayerEvents(global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.IPlatformMediaPlayer data) + { + _data = data; } - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable BufferingProgressUpdated => global::System.Reactive.Linq.Observable.FromEvent, global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.BufferingProgressUpdatedEventArgs>(eventHandler => + { + void Handler(object sender, global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.BufferingProgressUpdatedEventArgs e) => eventHandler(e); + return Handler; + }, x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable ErrorOccurred => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PlaybackCompleted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PlaybackPaused => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PlaybackStarted => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable PlaybackStopped => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + /// + /// Gets an observable which signals when the event triggers. + /// + public global::System.IObservable UpdateStreamInfo => global::System.Reactive.Linq.Observable.FromEvent(eventHandler => + { + void Handler(object sender, global::System.EventArgs e) => eventHandler(e); + return Handler; + }, x => _data.UpdateStreamInfo += x, x => _data.UpdateStreamInfo -= x); } } @@ -4355,8 +4531,6 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); + }, x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.monoandroid90.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.monoandroid90.approved.txt similarity index 92% rename from src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.monoandroid90.approved.txt rename to src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.monoandroid90.approved.txt index 42d3857..ab8ac96 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.monoandroid90.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.monoandroid90.approved.txt @@ -48,9 +48,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerClosedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); + }, x => _data.DrawerClosed += x, x => _data.DrawerClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -58,9 +56,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerOpenedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); + }, x => _data.DrawerOpened += x, x => _data.DrawerOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -68,9 +64,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerSlideEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); + }, x => _data.DrawerSlide += x, x => _data.DrawerSlide -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -78,9 +72,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.DrawerLayout.DrawerStateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); + }, x => _data.DrawerStateChanged += x, x => _data.DrawerStateChanged -= x); } /// @@ -105,9 +97,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::Android.Support.V4.Widget.NestedScrollView.ScrollChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); + }, x => _data.ScrollChange += x, x => _data.ScrollChange -= x); } /// @@ -132,9 +122,7 @@ namespace Android.Support.V4.Widget { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refresh += x, x => _data.Refresh -= x); + }, x => _data.Refresh += x, x => _data.Refresh -= x); } } @@ -177,9 +165,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.CapturedPointerEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); + }, x => _data.CapturedPointer += x, x => _data.CapturedPointer -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -187,9 +173,7 @@ namespace Android.Views { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Click += x, x => _data.Click -= x); + }, x => _data.Click += x, x => _data.Click -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -197,9 +181,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ContextClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextClick += x, x => _data.ContextClick -= x); + }, x => _data.ContextClick += x, x => _data.ContextClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -207,9 +189,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.CreateContextMenuEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); + }, x => _data.ContextMenuCreated += x, x => _data.ContextMenuCreated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -217,9 +197,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drag += x, x => _data.Drag -= x); + }, x => _data.Drag += x, x => _data.Drag -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -227,9 +205,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.FocusChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChange += x, x => _data.FocusChange -= x); + }, x => _data.FocusChange += x, x => _data.FocusChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -237,9 +213,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.GenericMotionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GenericMotion += x, x => _data.GenericMotion -= x); + }, x => _data.GenericMotion += x, x => _data.GenericMotion -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -247,9 +221,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.HoverEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Hover += x, x => _data.Hover -= x); + }, x => _data.Hover += x, x => _data.Hover -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -257,9 +229,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.KeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyPress += x, x => _data.KeyPress -= x); + }, x => _data.KeyPress += x, x => _data.KeyPress -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -267,9 +237,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.LayoutChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChange += x, x => _data.LayoutChange -= x); + }, x => _data.LayoutChange += x, x => _data.LayoutChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -277,9 +245,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.LongClickEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LongClick += x, x => _data.LongClick -= x); + }, x => _data.LongClick += x, x => _data.LongClick -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -287,9 +253,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ScrollChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollChange += x, x => _data.ScrollChange -= x); + }, x => _data.ScrollChange += x, x => _data.ScrollChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -297,9 +261,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.SystemUiVisibilityChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); + }, x => _data.SystemUiVisibilityChange += x, x => _data.SystemUiVisibilityChange -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -307,9 +269,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.TouchEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Touch += x, x => _data.Touch -= x); + }, x => _data.Touch += x, x => _data.Touch -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -317,9 +277,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.UnhandledKeyEventEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UnhandledKeyEvent += x, x => _data.UnhandledKeyEvent -= x); + }, x => _data.UnhandledKeyEvent += x, x => _data.UnhandledKeyEvent -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -327,9 +285,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ViewAttachedToWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); + }, x => _data.ViewAttachedToWindow += x, x => _data.ViewAttachedToWindow -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -337,9 +293,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.View.ViewDetachedFromWindowEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); + }, x => _data.ViewDetachedFromWindow += x, x => _data.ViewDetachedFromWindow -= x); } /// @@ -364,9 +318,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationEndEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); + }, x => _data.AnimationEnd += x, x => _data.AnimationEnd -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -374,9 +326,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationRepeatEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); + }, x => _data.AnimationRepeat += x, x => _data.AnimationRepeat -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -384,9 +334,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.Animations.Animation.AnimationStartEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationStart += x, x => _data.AnimationStart -= x); + }, x => _data.AnimationStart += x, x => _data.AnimationStart -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -394,9 +342,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.ViewGroup.ChildViewAddedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); + }, x => _data.ChildViewAdded += x, x => _data.ChildViewAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -404,9 +350,7 @@ namespace Android.Views { void Handler(object sender, global::Android.Views.ViewGroup.ChildViewRemovedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); + }, x => _data.ChildViewRemoved += x, x => _data.ChildViewRemoved -= x); } } @@ -449,9 +393,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.CompoundButton.CheckedChangeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChange += x, x => _data.CheckedChange -= x); + }, x => _data.CheckedChange += x, x => _data.CheckedChange -= x); } /// @@ -476,9 +418,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.AfterTextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); + }, x => _data.AfterTextChanged += x, x => _data.AfterTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -486,9 +426,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); + }, x => _data.BeforeTextChanged += x, x => _data.BeforeTextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -496,9 +434,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Widget.TextView.EditorActionEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EditorAction += x, x => _data.EditorAction -= x); + }, x => _data.EditorAction += x, x => _data.EditorAction -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -506,9 +442,7 @@ namespace Android.Widget { void Handler(object sender, global::Android.Text.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } } @@ -847,9 +781,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); + }, x => _data.ModalPopped += x, x => _data.ModalPopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -857,9 +789,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); + }, x => _data.ModalPopping += x, x => _data.ModalPopping -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -867,9 +797,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); + }, x => _data.ModalPushed += x, x => _data.ModalPushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -877,9 +805,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); + }, x => _data.ModalPushing += x, x => _data.ModalPushing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -887,9 +813,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); + }, x => _data.PageAppearing += x, x => _data.PageAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -897,9 +821,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); + }, x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -907,9 +829,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.AppThemeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RequestedThemeChanged += x, x => _data.RequestedThemeChanged -= x); + }, x => _data.RequestedThemeChanged += x, x => _data.RequestedThemeChanged -= x); } /// @@ -934,9 +854,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -944,9 +862,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); } /// @@ -971,9 +887,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -981,9 +895,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -991,9 +903,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); + }, x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); } /// @@ -1018,9 +928,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1028,9 +936,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1038,9 +944,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -1065,9 +969,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1075,9 +977,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } /// @@ -1102,9 +1002,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1112,9 +1010,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1122,9 +1018,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1132,9 +1026,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -1159,9 +1051,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -1186,9 +1076,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -1213,9 +1101,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -1240,9 +1126,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1267,9 +1151,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// @@ -1294,9 +1176,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); } /// @@ -1321,9 +1201,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DragStartingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarting += x, x => _data.DragStarting -= x); + }, x => _data.DragStarting += x, x => _data.DragStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1331,9 +1209,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DropCompletedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropCompleted += x, x => _data.DropCompleted -= x); + }, x => _data.DropCompleted += x, x => _data.DropCompleted -= x); } /// @@ -1358,9 +1234,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragOver += x, x => _data.DragOver -= x); + }, x => _data.DragOver += x, x => _data.DragOver -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1368,9 +1242,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DropEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drop += x, x => _data.Drop -= x); + }, x => _data.Drop += x, x => _data.Drop -= x); } /// @@ -1395,9 +1267,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1422,9 +1292,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); + }, x => _data.ChildAdded += x, x => _data.ChildAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1432,9 +1300,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); + }, x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1442,9 +1308,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); + }, x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1452,9 +1316,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); + }, x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1463,9 +1325,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1490,9 +1350,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1517,9 +1375,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1544,9 +1400,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -1571,9 +1425,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); } /// @@ -1598,9 +1450,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1626,9 +1476,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1653,9 +1501,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1680,9 +1526,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1707,9 +1551,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1734,9 +1576,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1744,9 +1584,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1754,9 +1592,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -1781,9 +1617,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); } /// @@ -1808,9 +1642,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1818,9 +1650,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1828,9 +1658,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1838,9 +1666,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1848,9 +1674,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1875,9 +1699,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -1902,9 +1724,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1929,9 +1749,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1956,9 +1774,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); + }, x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); } /// @@ -1983,9 +1799,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPageVisibleChanged += x, x => _data.IsPageVisibleChanged -= x); + }, x => _data.IsPageVisibleChanged += x, x => _data.IsPageVisibleChanged -= x); } /// @@ -2010,9 +1824,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2020,9 +1832,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); + }, x => _data.StructureChanged += x, x => _data.StructureChanged -= x); } /// @@ -2047,9 +1857,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); } /// @@ -2074,9 +1882,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2084,9 +1890,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); + }, x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); } /// @@ -2111,9 +1915,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -2138,9 +1940,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -2165,9 +1965,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); + }, x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2175,9 +1973,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2185,9 +1981,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2212,9 +2006,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2222,9 +2014,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); } /// @@ -2249,9 +2039,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2259,9 +2047,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2269,9 +2055,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2279,9 +2063,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } /// @@ -2306,9 +2088,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -2333,9 +2113,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); + }, x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2343,9 +2121,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); + }, x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2353,9 +2129,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2363,9 +2137,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); + }, x => _data.ItemTapped += x, x => _data.ItemTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2373,9 +2145,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2383,9 +2153,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2393,9 +2161,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2420,9 +2186,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -2447,9 +2211,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2457,9 +2219,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); } /// @@ -2484,9 +2244,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2494,9 +2252,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2504,9 +2260,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2514,9 +2268,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionRequested += x, x => _data.PositionRequested -= x); + }, x => _data.PositionRequested += x, x => _data.PositionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2524,9 +2276,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2534,9 +2284,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SeekRequested e) => eventHandler(e); return Handler; - } - - , x => _data.SeekRequested += x, x => _data.SeekRequested -= x); + }, x => _data.SeekRequested += x, x => _data.SeekRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2544,9 +2292,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.StateRequested e) => eventHandler(e); return Handler; - } - - , x => _data.StateRequested += x, x => _data.StateRequested -= x); + }, x => _data.StateRequested += x, x => _data.StateRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2554,9 +2300,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VolumeRequested += x, x => _data.VolumeRequested -= x); + }, x => _data.VolumeRequested += x, x => _data.VolumeRequested -= x); } /// @@ -2581,9 +2325,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -2608,9 +2350,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2618,9 +2358,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2628,9 +2366,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); + }, x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2638,9 +2374,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2648,9 +2382,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2658,9 +2390,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); + }, x => _data.Pushed += x, x => _data.Pushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2668,9 +2398,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2678,9 +2406,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -2705,9 +2431,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -2732,9 +2456,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2742,9 +2464,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2752,9 +2472,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -2779,9 +2497,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); + }, x => _data.PanUpdated += x, x => _data.PanUpdated -= x); } /// @@ -2806,9 +2522,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -2833,9 +2547,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); + }, x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); } /// @@ -2860,9 +2572,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -2887,9 +2597,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); } /// @@ -2914,9 +2622,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -2941,9 +2647,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2951,9 +2655,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2978,9 +2680,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); + }, x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); } /// @@ -3005,9 +2705,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3015,9 +2713,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3025,9 +2721,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -3052,9 +2746,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -3079,9 +2771,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3089,9 +2779,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); } /// @@ -3116,9 +2804,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3126,9 +2812,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3136,9 +2820,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -3163,9 +2845,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsActiveChanged += x, x => _data.IsActiveChanged -= x); + }, x => _data.IsActiveChanged += x, x => _data.IsActiveChanged -= x); } /// @@ -3190,9 +2870,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -3217,9 +2895,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); + }, x => _data.Swiped += x, x => _data.Swiped -= x); } /// @@ -3244,9 +2920,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -3271,9 +2945,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -3298,9 +2970,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -3325,9 +2995,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3335,9 +3003,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.OpenSwipeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OpenRequested += x, x => _data.OpenRequested -= x); + }, x => _data.OpenRequested += x, x => _data.OpenRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3345,9 +3011,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); + }, x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3355,9 +3019,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeEndedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); + }, x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3365,9 +3027,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); + }, x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); } /// @@ -3392,9 +3052,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -3419,9 +3077,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); + }, x => _data.OnChanged += x, x => _data.OnChanged -= x); } /// @@ -3446,9 +3102,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -3473,9 +3127,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -3501,9 +3153,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); } /// @@ -3528,9 +3178,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3538,9 +3186,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); + }, x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3548,9 +3194,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3558,9 +3202,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3568,9 +3210,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3578,9 +3218,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3588,9 +3226,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -3615,9 +3251,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3625,9 +3259,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3635,9 +3267,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3645,9 +3275,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3655,9 +3283,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3665,9 +3291,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } } @@ -3718,9 +3342,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -3745,9 +3367,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); + }, x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); } /// @@ -3772,9 +3392,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3782,9 +3400,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -3809,9 +3425,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } } @@ -3942,9 +3556,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3952,9 +3564,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -3979,9 +3589,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationStarted += x, x => _data.AnimationStarted -= x); + }, x => _data.AnimationStarted += x, x => _data.AnimationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3989,9 +3597,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.FormsAnimationDrawableStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationStopped += x, x => _data.AnimationStopped -= x); + }, x => _data.AnimationStopped += x, x => _data.AnimationStopped -= x); } /// @@ -4016,9 +3622,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } /// @@ -4043,9 +3647,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } /// @@ -4070,9 +3672,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -4097,9 +3697,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -4124,9 +3722,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); + }, x => _data.ConfigurationChanged += x, x => _data.ConfigurationChanged -= x); } /// @@ -4151,9 +3747,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationStarted += x, x => _data.AnimationStarted -= x); + }, x => _data.AnimationStarted += x, x => _data.AnimationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4161,9 +3755,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.FormsAnimationDrawableStateEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationStopped += x, x => _data.AnimationStopped -= x); + }, x => _data.AnimationStopped += x, x => _data.AnimationStopped -= x); } /// @@ -4188,9 +3780,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4198,9 +3788,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -4225,9 +3813,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4235,9 +3821,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -4262,9 +3846,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); } /// @@ -4289,9 +3871,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); + }, x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); } /// @@ -4316,9 +3896,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); + }, x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); } /// @@ -4343,9 +3921,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4353,9 +3929,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -4380,9 +3954,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -4407,9 +3979,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4417,9 +3987,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -4444,9 +4012,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4454,9 +4020,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -4481,9 +4045,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4491,9 +4053,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -4518,9 +4078,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -4545,9 +4103,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, int e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -4572,9 +4128,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); + }, x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); } /// @@ -4599,9 +4153,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Destroyed += x, x => _data.Destroyed -= x); + }, x => _data.Destroyed += x, x => _data.Destroyed -= x); } /// @@ -4626,9 +4178,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); + }, x => _data.SearchConfirmed += x, x => _data.SearchConfirmed -= x); } /// @@ -4653,9 +4203,7 @@ namespace Xamarin.Forms.Platform.Android { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); + }, x => _data.AnimationFinished += x, x => _data.AnimationFinished -= x); } } @@ -4706,9 +4254,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4716,9 +4262,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -4743,9 +4287,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4753,9 +4295,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -4780,9 +4320,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4790,9 +4328,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -4817,9 +4353,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::Xamarin.Forms.Platform.Android.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4827,9 +4361,7 @@ namespace Xamarin.Forms.Platform.Android.FastRenderers { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } } @@ -4872,9 +4404,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4882,9 +4412,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4892,9 +4420,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); } /// @@ -4919,9 +4445,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.BufferingProgressUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); + }, x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4929,9 +4453,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4939,9 +4461,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); + }, x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4949,9 +4469,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4959,9 +4477,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4969,9 +4485,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4979,9 +4493,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UpdateStreamInfo += x, x => _data.UpdateStreamInfo -= x); + }, x => _data.UpdateStreamInfo += x, x => _data.UpdateStreamInfo -= x); } } @@ -4999,8 +4511,6 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); + }, x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.netstandard2.0.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.netstandard2.0.approved.txt similarity index 92% rename from src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.netstandard2.0.approved.txt rename to src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.netstandard2.0.approved.txt index 564d875..dfb5975 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.netstandard2.0.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.netstandard2.0.approved.txt @@ -340,9 +340,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); + }, x => _data.ModalPopped += x, x => _data.ModalPopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -350,9 +348,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); + }, x => _data.ModalPopping += x, x => _data.ModalPopping -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -360,9 +356,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); + }, x => _data.ModalPushed += x, x => _data.ModalPushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -370,9 +364,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); + }, x => _data.ModalPushing += x, x => _data.ModalPushing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -380,9 +372,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); + }, x => _data.PageAppearing += x, x => _data.PageAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -390,9 +380,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); + }, x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -400,9 +388,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.AppThemeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RequestedThemeChanged += x, x => _data.RequestedThemeChanged -= x); + }, x => _data.RequestedThemeChanged += x, x => _data.RequestedThemeChanged -= x); } /// @@ -427,9 +413,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -437,9 +421,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); } /// @@ -464,9 +446,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -474,9 +454,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -484,9 +462,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); + }, x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); } /// @@ -511,9 +487,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -521,9 +495,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -531,9 +503,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -558,9 +528,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -568,9 +536,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } /// @@ -595,9 +561,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -605,9 +569,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -615,9 +577,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -625,9 +585,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -652,9 +610,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -679,9 +635,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -706,9 +660,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -733,9 +685,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -760,9 +710,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// @@ -787,9 +735,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); } /// @@ -814,9 +760,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DragStartingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarting += x, x => _data.DragStarting -= x); + }, x => _data.DragStarting += x, x => _data.DragStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -824,9 +768,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DropCompletedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropCompleted += x, x => _data.DropCompleted -= x); + }, x => _data.DropCompleted += x, x => _data.DropCompleted -= x); } /// @@ -851,9 +793,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragOver += x, x => _data.DragOver -= x); + }, x => _data.DragOver += x, x => _data.DragOver -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -861,9 +801,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DropEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drop += x, x => _data.Drop -= x); + }, x => _data.Drop += x, x => _data.Drop -= x); } /// @@ -888,9 +826,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -915,9 +851,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); + }, x => _data.ChildAdded += x, x => _data.ChildAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -925,9 +859,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); + }, x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -935,9 +867,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); + }, x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -945,9 +875,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); + }, x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -956,9 +884,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -983,9 +909,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1010,9 +934,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1037,9 +959,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -1064,9 +984,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); } /// @@ -1091,9 +1009,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1119,9 +1035,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1146,9 +1060,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1173,9 +1085,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1200,9 +1110,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1227,9 +1135,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1237,9 +1143,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1247,9 +1151,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -1274,9 +1176,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); } /// @@ -1301,9 +1201,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1311,9 +1209,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1321,9 +1217,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1331,9 +1225,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1341,9 +1233,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1368,9 +1258,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -1395,9 +1283,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1422,9 +1308,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1449,9 +1333,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); + }, x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); } /// @@ -1476,9 +1358,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPageVisibleChanged += x, x => _data.IsPageVisibleChanged -= x); + }, x => _data.IsPageVisibleChanged += x, x => _data.IsPageVisibleChanged -= x); } /// @@ -1503,9 +1383,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1513,9 +1391,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); + }, x => _data.StructureChanged += x, x => _data.StructureChanged -= x); } /// @@ -1540,9 +1416,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); } /// @@ -1567,9 +1441,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1577,9 +1449,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); + }, x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); } /// @@ -1604,9 +1474,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -1631,9 +1499,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -1658,9 +1524,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); + }, x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1668,9 +1532,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1678,9 +1540,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1705,9 +1565,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1715,9 +1573,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); } /// @@ -1742,9 +1598,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1752,9 +1606,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1762,9 +1614,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1772,9 +1622,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } /// @@ -1799,9 +1647,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1826,9 +1672,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); + }, x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1836,9 +1680,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); + }, x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1846,9 +1688,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1856,9 +1696,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); + }, x => _data.ItemTapped += x, x => _data.ItemTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1866,9 +1704,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1876,9 +1712,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1886,9 +1720,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1913,9 +1745,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1940,9 +1770,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1950,9 +1778,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); } /// @@ -1977,9 +1803,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1987,9 +1811,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1997,9 +1819,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2007,9 +1827,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionRequested += x, x => _data.PositionRequested -= x); + }, x => _data.PositionRequested += x, x => _data.PositionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2017,9 +1835,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2027,9 +1843,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SeekRequested e) => eventHandler(e); return Handler; - } - - , x => _data.SeekRequested += x, x => _data.SeekRequested -= x); + }, x => _data.SeekRequested += x, x => _data.SeekRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2037,9 +1851,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.StateRequested e) => eventHandler(e); return Handler; - } - - , x => _data.StateRequested += x, x => _data.StateRequested -= x); + }, x => _data.StateRequested += x, x => _data.StateRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2047,9 +1859,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VolumeRequested += x, x => _data.VolumeRequested -= x); + }, x => _data.VolumeRequested += x, x => _data.VolumeRequested -= x); } /// @@ -2074,9 +1884,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -2101,9 +1909,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2111,9 +1917,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2121,9 +1925,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); + }, x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2131,9 +1933,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2141,9 +1941,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2151,9 +1949,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); + }, x => _data.Pushed += x, x => _data.Pushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2161,9 +1957,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2171,9 +1965,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -2198,9 +1990,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -2225,9 +2015,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2235,9 +2023,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2245,9 +2031,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -2272,9 +2056,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); + }, x => _data.PanUpdated += x, x => _data.PanUpdated -= x); } /// @@ -2299,9 +2081,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -2326,9 +2106,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); + }, x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); } /// @@ -2353,9 +2131,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -2380,9 +2156,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); } /// @@ -2407,9 +2181,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -2434,9 +2206,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2444,9 +2214,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2471,9 +2239,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); + }, x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); } /// @@ -2498,9 +2264,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2508,9 +2272,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2518,9 +2280,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2545,9 +2305,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -2572,9 +2330,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2582,9 +2338,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); } /// @@ -2609,9 +2363,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2619,9 +2371,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2629,9 +2379,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2656,9 +2404,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsActiveChanged += x, x => _data.IsActiveChanged -= x); + }, x => _data.IsActiveChanged += x, x => _data.IsActiveChanged -= x); } /// @@ -2683,9 +2429,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2710,9 +2454,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); + }, x => _data.Swiped += x, x => _data.Swiped -= x); } /// @@ -2737,9 +2479,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -2764,9 +2504,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -2791,9 +2529,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -2818,9 +2554,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2828,9 +2562,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.OpenSwipeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OpenRequested += x, x => _data.OpenRequested -= x); + }, x => _data.OpenRequested += x, x => _data.OpenRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2838,9 +2570,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); + }, x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2848,9 +2578,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeEndedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); + }, x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2858,9 +2586,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); + }, x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); } /// @@ -2885,9 +2611,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -2912,9 +2636,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); + }, x => _data.OnChanged += x, x => _data.OnChanged -= x); } /// @@ -2939,9 +2661,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -2966,9 +2686,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -2994,9 +2712,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); } /// @@ -3021,9 +2737,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3031,9 +2745,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); + }, x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3041,9 +2753,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3051,9 +2761,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3061,9 +2769,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3071,9 +2777,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3081,9 +2785,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -3108,9 +2810,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3118,9 +2818,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3128,9 +2826,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3138,9 +2834,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3148,9 +2842,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3158,9 +2850,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } } @@ -3211,9 +2901,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -3238,9 +2926,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); + }, x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); } /// @@ -3265,9 +2951,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3275,9 +2959,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -3302,9 +2984,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } } @@ -3347,9 +3027,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3357,9 +3035,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3367,9 +3043,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); } /// @@ -3394,9 +3068,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.BufferingProgressUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); + }, x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3404,9 +3076,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3414,9 +3084,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); + }, x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3424,9 +3092,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3434,9 +3100,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3444,9 +3108,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3454,8 +3116,6 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UpdateStreamInfo += x, x => _data.UpdateStreamInfo -= x); + }, x => _data.UpdateStreamInfo += x, x => _data.UpdateStreamInfo -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.tizen40.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.tizen40.approved.txt similarity index 92% rename from src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.tizen40.approved.txt rename to src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.tizen40.approved.txt index 4f0f06e..9fb140f 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.tizen40.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.tizen40.approved.txt @@ -68,9 +68,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -78,9 +76,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChangedByUser += x, x => _data.ChangedByUser -= x); + }, x => _data.ChangedByUser += x, x => _data.ChangedByUser -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -88,9 +84,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -98,9 +92,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CursorChanged += x, x => _data.CursorChanged -= x); + }, x => _data.CursorChanged += x, x => _data.CursorChanged -= x); } /// @@ -125,9 +117,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -135,9 +125,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Deleted += x, x => _data.Deleted -= x); + }, x => _data.Deleted += x, x => _data.Deleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -145,9 +133,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyDown += x, x => _data.KeyDown -= x); + }, x => _data.KeyDown += x, x => _data.KeyDown -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -155,9 +141,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.EvasKeyEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.KeyUp += x, x => _data.KeyUp -= x); + }, x => _data.KeyUp += x, x => _data.KeyUp -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -165,9 +149,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MoreButtonPressed += x, x => _data.MoreButtonPressed -= x); + }, x => _data.MoreButtonPressed += x, x => _data.MoreButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -175,9 +157,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Moved += x, x => _data.Moved -= x); + }, x => _data.Moved += x, x => _data.Moved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -185,9 +165,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RenderPost += x, x => _data.RenderPost -= x); + }, x => _data.RenderPost += x, x => _data.RenderPost -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -195,9 +173,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Resized += x, x => _data.Resized -= x); + }, x => _data.Resized += x, x => _data.Resized -= x); } /// @@ -222,9 +198,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -232,9 +206,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemActivated += x, x => _data.ItemActivated -= x); + }, x => _data.ItemActivated += x, x => _data.ItemActivated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -242,9 +214,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDoubleClicked += x, x => _data.ItemDoubleClicked -= x); + }, x => _data.ItemDoubleClicked += x, x => _data.ItemDoubleClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -252,9 +222,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemExpanded += x, x => _data.ItemExpanded -= x); + }, x => _data.ItemExpanded += x, x => _data.ItemExpanded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -262,9 +230,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -272,9 +238,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemMoved += x, x => _data.ItemMoved -= x); + }, x => _data.ItemMoved += x, x => _data.ItemMoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -282,9 +246,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemMovedAfter += x, x => _data.ItemMovedAfter -= x); + }, x => _data.ItemMovedAfter += x, x => _data.ItemMovedAfter -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -292,9 +254,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemMovedBefore += x, x => _data.ItemMovedBefore -= x); + }, x => _data.ItemMovedBefore += x, x => _data.ItemMovedBefore -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -302,9 +262,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemPressed += x, x => _data.ItemPressed -= x); + }, x => _data.ItemPressed += x, x => _data.ItemPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -312,9 +270,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemRealized += x, x => _data.ItemRealized -= x); + }, x => _data.ItemRealized += x, x => _data.ItemRealized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -322,9 +278,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemReleased += x, x => _data.ItemReleased -= x); + }, x => _data.ItemReleased += x, x => _data.ItemReleased -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -332,9 +286,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -342,9 +294,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemUnrealized += x, x => _data.ItemUnrealized -= x); + }, x => _data.ItemUnrealized += x, x => _data.ItemUnrealized -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -352,9 +302,7 @@ namespace ElmSharp { void Handler(object sender, global::ElmSharp.GenListItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemUnselected += x, x => _data.ItemUnselected -= x); + }, x => _data.ItemUnselected += x, x => _data.ItemUnselected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -362,9 +310,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollAnimationStarted += x, x => _data.ScrollAnimationStarted -= x); + }, x => _data.ScrollAnimationStarted += x, x => _data.ScrollAnimationStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -372,9 +318,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollAnimationStopped += x, x => _data.ScrollAnimationStopped -= x); + }, x => _data.ScrollAnimationStopped += x, x => _data.ScrollAnimationStopped -= x); } /// @@ -399,9 +343,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Changed += x, x => _data.Changed -= x); + }, x => _data.Changed += x, x => _data.Changed -= x); } /// @@ -426,9 +368,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); + }, x => _data.LanguageChanged += x, x => _data.LanguageChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -436,9 +376,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ThemeChanged += x, x => _data.ThemeChanged -= x); + }, x => _data.ThemeChanged += x, x => _data.ThemeChanged -= x); } /// @@ -463,9 +401,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dismissed += x, x => _data.Dismissed -= x); + }, x => _data.Dismissed += x, x => _data.Dismissed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -473,9 +409,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OutsideClicked += x, x => _data.OutsideClicked -= x); + }, x => _data.OutsideClicked += x, x => _data.OutsideClicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -483,9 +417,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ShowAnimationFinished += x, x => _data.ShowAnimationFinished -= x); + }, x => _data.ShowAnimationFinished += x, x => _data.ShowAnimationFinished -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -493,9 +425,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TimedOut += x, x => _data.TimedOut -= x); + }, x => _data.TimedOut += x, x => _data.TimedOut -= x); } /// @@ -520,9 +450,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DelayedValueChanged += x, x => _data.DelayedValueChanged -= x); + }, x => _data.DelayedValueChanged += x, x => _data.DelayedValueChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -530,9 +458,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -557,9 +483,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -567,9 +491,7 @@ namespace ElmSharp { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } } @@ -908,9 +830,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); + }, x => _data.ModalPopped += x, x => _data.ModalPopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -918,9 +838,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); + }, x => _data.ModalPopping += x, x => _data.ModalPopping -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -928,9 +846,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); + }, x => _data.ModalPushed += x, x => _data.ModalPushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -938,9 +854,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); + }, x => _data.ModalPushing += x, x => _data.ModalPushing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -948,9 +862,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); + }, x => _data.PageAppearing += x, x => _data.PageAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -958,9 +870,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); + }, x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -968,9 +878,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.AppThemeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RequestedThemeChanged += x, x => _data.RequestedThemeChanged -= x); + }, x => _data.RequestedThemeChanged += x, x => _data.RequestedThemeChanged -= x); } /// @@ -995,9 +903,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1005,9 +911,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); } /// @@ -1032,9 +936,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1042,9 +944,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1052,9 +952,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); + }, x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); } /// @@ -1079,9 +977,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1089,9 +985,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1099,9 +993,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -1126,9 +1018,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1136,9 +1026,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } /// @@ -1163,9 +1051,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1173,9 +1059,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1183,9 +1067,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1193,9 +1075,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -1220,9 +1100,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -1247,9 +1125,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -1274,9 +1150,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -1301,9 +1175,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1328,9 +1200,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// @@ -1355,9 +1225,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); } /// @@ -1382,9 +1250,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DragStartingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarting += x, x => _data.DragStarting -= x); + }, x => _data.DragStarting += x, x => _data.DragStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1392,9 +1258,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DropCompletedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropCompleted += x, x => _data.DropCompleted -= x); + }, x => _data.DropCompleted += x, x => _data.DropCompleted -= x); } /// @@ -1419,9 +1283,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragOver += x, x => _data.DragOver -= x); + }, x => _data.DragOver += x, x => _data.DragOver -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1429,9 +1291,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DropEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drop += x, x => _data.Drop -= x); + }, x => _data.Drop += x, x => _data.Drop -= x); } /// @@ -1456,9 +1316,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1483,9 +1341,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); + }, x => _data.ChildAdded += x, x => _data.ChildAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1493,9 +1349,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); + }, x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1503,9 +1357,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); + }, x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1513,9 +1365,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); + }, x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1524,9 +1374,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1551,9 +1399,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1578,9 +1424,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1605,9 +1449,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -1632,9 +1474,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); } /// @@ -1659,9 +1499,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1687,9 +1525,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1714,9 +1550,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1741,9 +1575,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1768,9 +1600,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1795,9 +1625,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1805,9 +1633,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1815,9 +1641,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -1842,9 +1666,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); } /// @@ -1869,9 +1691,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1879,9 +1699,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1889,9 +1707,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1899,9 +1715,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1909,9 +1723,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1936,9 +1748,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -1963,9 +1773,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1990,9 +1798,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2017,9 +1823,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); + }, x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); } /// @@ -2044,9 +1848,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPageVisibleChanged += x, x => _data.IsPageVisibleChanged -= x); + }, x => _data.IsPageVisibleChanged += x, x => _data.IsPageVisibleChanged -= x); } /// @@ -2071,9 +1873,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2081,9 +1881,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); + }, x => _data.StructureChanged += x, x => _data.StructureChanged -= x); } /// @@ -2108,9 +1906,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); } /// @@ -2135,9 +1931,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2145,9 +1939,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); + }, x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); } /// @@ -2172,9 +1964,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -2199,9 +1989,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -2226,9 +2014,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); + }, x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2236,9 +2022,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2246,9 +2030,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2273,9 +2055,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2283,9 +2063,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); } /// @@ -2310,9 +2088,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2320,9 +2096,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2330,9 +2104,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2340,9 +2112,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } /// @@ -2367,9 +2137,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -2394,9 +2162,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); + }, x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2404,9 +2170,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); + }, x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2414,9 +2178,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2424,9 +2186,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); + }, x => _data.ItemTapped += x, x => _data.ItemTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2434,9 +2194,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2444,9 +2202,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2454,9 +2210,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2481,9 +2235,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -2508,9 +2260,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2518,9 +2268,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); } /// @@ -2545,9 +2293,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2555,9 +2301,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2565,9 +2309,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2575,9 +2317,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionRequested += x, x => _data.PositionRequested -= x); + }, x => _data.PositionRequested += x, x => _data.PositionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2585,9 +2325,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2595,9 +2333,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SeekRequested e) => eventHandler(e); return Handler; - } - - , x => _data.SeekRequested += x, x => _data.SeekRequested -= x); + }, x => _data.SeekRequested += x, x => _data.SeekRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2605,9 +2341,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.StateRequested e) => eventHandler(e); return Handler; - } - - , x => _data.StateRequested += x, x => _data.StateRequested -= x); + }, x => _data.StateRequested += x, x => _data.StateRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2615,9 +2349,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VolumeRequested += x, x => _data.VolumeRequested -= x); + }, x => _data.VolumeRequested += x, x => _data.VolumeRequested -= x); } /// @@ -2642,9 +2374,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -2669,9 +2399,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2679,9 +2407,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2689,9 +2415,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); + }, x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2699,9 +2423,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2709,9 +2431,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2719,9 +2439,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); + }, x => _data.Pushed += x, x => _data.Pushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2729,9 +2447,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2739,9 +2455,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -2766,9 +2480,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -2793,9 +2505,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2803,9 +2513,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2813,9 +2521,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -2840,9 +2546,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); + }, x => _data.PanUpdated += x, x => _data.PanUpdated -= x); } /// @@ -2867,9 +2571,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -2894,9 +2596,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); + }, x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); } /// @@ -2921,9 +2621,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -2948,9 +2646,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); } /// @@ -2975,9 +2671,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -3002,9 +2696,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3012,9 +2704,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -3039,9 +2729,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); + }, x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); } /// @@ -3066,9 +2754,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3076,9 +2762,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3086,9 +2770,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -3113,9 +2795,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -3140,9 +2820,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3150,9 +2828,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); } /// @@ -3177,9 +2853,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3187,9 +2861,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3197,9 +2869,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -3224,9 +2894,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsActiveChanged += x, x => _data.IsActiveChanged -= x); + }, x => _data.IsActiveChanged += x, x => _data.IsActiveChanged -= x); } /// @@ -3251,9 +2919,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -3278,9 +2944,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); + }, x => _data.Swiped += x, x => _data.Swiped -= x); } /// @@ -3305,9 +2969,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -3332,9 +2994,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -3359,9 +3019,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -3386,9 +3044,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3396,9 +3052,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.OpenSwipeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OpenRequested += x, x => _data.OpenRequested -= x); + }, x => _data.OpenRequested += x, x => _data.OpenRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3406,9 +3060,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); + }, x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3416,9 +3068,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeEndedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); + }, x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3426,9 +3076,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); + }, x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); } /// @@ -3453,9 +3101,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -3480,9 +3126,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); + }, x => _data.OnChanged += x, x => _data.OnChanged -= x); } /// @@ -3507,9 +3151,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -3534,9 +3176,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -3562,9 +3202,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); } /// @@ -3589,9 +3227,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3599,9 +3235,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); + }, x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3609,9 +3243,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3619,9 +3251,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3629,9 +3259,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3639,9 +3267,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3649,9 +3275,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -3676,9 +3300,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3686,9 +3308,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3696,9 +3316,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3706,9 +3324,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3716,9 +3332,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3726,9 +3340,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } } @@ -3779,9 +3391,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -3806,9 +3416,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); + }, x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); } /// @@ -3833,9 +3441,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3843,9 +3449,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -3870,9 +3474,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } } @@ -3943,9 +3545,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); + }, x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); } /// @@ -3970,9 +3570,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -3997,9 +3595,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -4024,9 +3620,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); } /// @@ -4051,9 +3645,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::ElmSharp.ToolbarItemEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } /// @@ -4078,9 +3670,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); + }, x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); } /// @@ -4105,9 +3695,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.RootNativeViewChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); + }, x => _data.RootNativeViewChanged += x, x => _data.RootNativeViewChanged -= x); } /// @@ -4132,9 +3720,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -4159,9 +3745,7 @@ namespace Xamarin.Forms.Platform.Tizen { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); + }, x => _data.SelectedItemChanged += x, x => _data.SelectedItemChanged -= x); } } @@ -4260,9 +3844,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); } /// @@ -4287,9 +3869,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); } /// @@ -4314,9 +3894,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); + }, x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4324,9 +3902,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PickerClosed += x, x => _data.PickerClosed -= x); + }, x => _data.PickerClosed += x, x => _data.PickerClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4334,9 +3910,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PickerOpened += x, x => _data.PickerOpened -= x); + }, x => _data.PickerOpened += x, x => _data.PickerOpened -= x); } /// @@ -4361,9 +3935,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Shown += x, x => _data.Shown -= x); + }, x => _data.Shown += x, x => _data.Shown -= x); } /// @@ -4388,9 +3960,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EntryLayoutFocused += x, x => _data.EntryLayoutFocused -= x); + }, x => _data.EntryLayoutFocused += x, x => _data.EntryLayoutFocused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4398,9 +3968,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EntryLayoutUnfocused += x, x => _data.EntryLayoutUnfocused -= x); + }, x => _data.EntryLayoutUnfocused += x, x => _data.EntryLayoutUnfocused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4408,9 +3976,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextBlockFocused += x, x => _data.TextBlockFocused -= x); + }, x => _data.TextBlockFocused += x, x => _data.TextBlockFocused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4418,9 +3984,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextBlockUnfocused += x, x => _data.TextBlockUnfocused -= x); + }, x => _data.TextBlockUnfocused += x, x => _data.TextBlockUnfocused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4428,9 +3992,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -4455,9 +4017,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); + }, x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4465,9 +4025,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PickerClosed += x, x => _data.PickerClosed -= x); + }, x => _data.PickerClosed += x, x => _data.PickerClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4475,9 +4033,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PickerOpened += x, x => _data.PickerOpened -= x); + }, x => _data.PickerOpened += x, x => _data.PickerOpened -= x); } /// @@ -4502,9 +4058,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EntryLayoutFocused += x, x => _data.EntryLayoutFocused -= x); + }, x => _data.EntryLayoutFocused += x, x => _data.EntryLayoutFocused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4512,9 +4066,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.EntryLayoutUnfocused += x, x => _data.EntryLayoutUnfocused -= x); + }, x => _data.EntryLayoutUnfocused += x, x => _data.EntryLayoutUnfocused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4522,9 +4074,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextBlockFocused += x, x => _data.TextBlockFocused -= x); + }, x => _data.TextBlockFocused += x, x => _data.TextBlockFocused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4532,9 +4082,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextBlockUnfocused += x, x => _data.TextBlockUnfocused -= x); + }, x => _data.TextBlockUnfocused += x, x => _data.TextBlockUnfocused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4542,9 +4090,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -4569,9 +4115,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.SelectedPositionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedPosition += x, x => _data.SelectedPosition -= x); + }, x => _data.SelectedPosition += x, x => _data.SelectedPosition -= x); } /// @@ -4596,9 +4140,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -4623,9 +4165,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); } /// @@ -4650,9 +4190,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); } /// @@ -4677,9 +4215,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.IsPresentedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4687,9 +4223,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.UpdateIsPresentChangeableEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UpdateIsPresentChangeable += x, x => _data.UpdateIsPresentChangeable -= x); + }, x => _data.UpdateIsPresentChangeable += x, x => _data.UpdateIsPresentChangeable -= x); } /// @@ -4714,9 +4248,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingCompleted += x, x => _data.BufferingCompleted -= x); + }, x => _data.BufferingCompleted += x, x => _data.BufferingCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4724,9 +4256,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.BufferingProgressUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); + }, x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4734,9 +4264,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); + }, x => _data.BufferingStarted += x, x => _data.BufferingStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4744,9 +4272,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4754,9 +4280,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaPrepared += x, x => _data.MediaPrepared -= x); + }, x => _data.MediaPrepared += x, x => _data.MediaPrepared -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4764,9 +4288,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); + }, x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4774,9 +4296,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4784,9 +4304,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4794,9 +4312,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); } /// @@ -4821,9 +4337,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.BufferingProgressUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); + }, x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4831,9 +4345,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4841,9 +4353,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); + }, x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4851,9 +4361,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4861,9 +4369,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4871,9 +4377,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4881,9 +4385,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UpdateStreamInfo += x, x => _data.UpdateStreamInfo -= x); + }, x => _data.UpdateStreamInfo += x, x => _data.UpdateStreamInfo -= x); } /// @@ -4908,9 +4410,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.LayoutEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); + }, x => _data.LayoutUpdated += x, x => _data.LayoutUpdated -= x); } /// @@ -4935,9 +4435,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RequestSelected += x, x => _data.RequestSelected -= x); + }, x => _data.RequestSelected += x, x => _data.RequestSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -4945,9 +4443,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Selected += x, x => _data.Selected -= x); + }, x => _data.Selected += x, x => _data.Selected -= x); } } @@ -4990,9 +4486,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native.Watch { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Native.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); + }, x => _data.DateTimeChanged += x, x => _data.DateTimeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5000,9 +4494,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native.Watch { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PickerClosed += x, x => _data.PickerClosed -= x); + }, x => _data.PickerClosed += x, x => _data.PickerClosed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5010,9 +4502,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native.Watch { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PickerOpened += x, x => _data.PickerOpened -= x); + }, x => _data.PickerOpened += x, x => _data.PickerOpened -= x); } /// @@ -5037,9 +4527,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native.Watch { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WheelAppeared += x, x => _data.WheelAppeared -= x); + }, x => _data.WheelAppeared += x, x => _data.WheelAppeared -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5047,9 +4535,7 @@ namespace Xamarin.Forms.Platform.Tizen.Native.Watch { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.WheelDisappeared += x, x => _data.WheelDisappeared -= x); + }, x => _data.WheelDisappeared += x, x => _data.WheelDisappeared -= x); } } @@ -5092,9 +4578,7 @@ namespace Xamarin.Forms.Platform.Tizen.Watch { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -5119,9 +4603,7 @@ namespace Xamarin.Forms.Platform.Tizen.Watch { void Handler(object sender, global::Xamarin.Forms.Platform.Tizen.Watch.DraggedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Dragged += x, x => _data.Dragged -= x); + }, x => _data.Dragged += x, x => _data.Dragged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5129,9 +4611,7 @@ namespace Xamarin.Forms.Platform.Tizen.Watch { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } } @@ -5174,9 +4654,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5184,9 +4662,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5194,9 +4670,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); } /// @@ -5221,9 +4695,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.BufferingProgressUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); + }, x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5231,9 +4703,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5241,9 +4711,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); + }, x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5251,9 +4719,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5261,9 +4727,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5271,9 +4735,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -5281,9 +4743,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UpdateStreamInfo += x, x => _data.UpdateStreamInfo -= x); + }, x => _data.UpdateStreamInfo += x, x => _data.UpdateStreamInfo -= x); } } @@ -5301,8 +4761,6 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ViewInitializedEventArgs e) => eventHandler(e); return Handler; - } - - , x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); + }, x => global::Xamarin.Forms.Forms.ViewInitialized += x, x => global::Xamarin.Forms.Forms.ViewInitialized -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.uap10.0.17763.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.uap10.0.17763.approved.txt similarity index 92% rename from src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.uap10.0.17763.approved.txt rename to src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.uap10.0.17763.approved.txt index 3f94404..5a70081 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.uap10.0.17763.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.uap10.0.17763.approved.txt @@ -340,9 +340,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); + }, x => _data.ModalPopped += x, x => _data.ModalPopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -350,9 +348,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); + }, x => _data.ModalPopping += x, x => _data.ModalPopping -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -360,9 +356,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); + }, x => _data.ModalPushed += x, x => _data.ModalPushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -370,9 +364,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); + }, x => _data.ModalPushing += x, x => _data.ModalPushing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -380,9 +372,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); + }, x => _data.PageAppearing += x, x => _data.PageAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -390,9 +380,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); + }, x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -400,9 +388,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.AppThemeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RequestedThemeChanged += x, x => _data.RequestedThemeChanged -= x); + }, x => _data.RequestedThemeChanged += x, x => _data.RequestedThemeChanged -= x); } /// @@ -427,9 +413,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -437,9 +421,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); } /// @@ -464,9 +446,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -474,9 +454,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -484,9 +462,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); + }, x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); } /// @@ -511,9 +487,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -521,9 +495,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -531,9 +503,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -558,9 +528,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -568,9 +536,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } /// @@ -595,9 +561,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -605,9 +569,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -615,9 +577,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -625,9 +585,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -652,9 +610,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -679,9 +635,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -706,9 +660,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -733,9 +685,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -760,9 +710,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// @@ -787,9 +735,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); } /// @@ -814,9 +760,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DragStartingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarting += x, x => _data.DragStarting -= x); + }, x => _data.DragStarting += x, x => _data.DragStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -824,9 +768,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DropCompletedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropCompleted += x, x => _data.DropCompleted -= x); + }, x => _data.DropCompleted += x, x => _data.DropCompleted -= x); } /// @@ -851,9 +793,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragOver += x, x => _data.DragOver -= x); + }, x => _data.DragOver += x, x => _data.DragOver -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -861,9 +801,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DropEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drop += x, x => _data.Drop -= x); + }, x => _data.Drop += x, x => _data.Drop -= x); } /// @@ -888,9 +826,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -915,9 +851,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); + }, x => _data.ChildAdded += x, x => _data.ChildAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -925,9 +859,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); + }, x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -935,9 +867,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); + }, x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -945,9 +875,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); + }, x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -956,9 +884,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -983,9 +909,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1010,9 +934,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1037,9 +959,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -1064,9 +984,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); } /// @@ -1091,9 +1009,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1119,9 +1035,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1146,9 +1060,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1173,9 +1085,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1200,9 +1110,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1227,9 +1135,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1237,9 +1143,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1247,9 +1151,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -1274,9 +1176,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); } /// @@ -1301,9 +1201,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1311,9 +1209,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1321,9 +1217,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1331,9 +1225,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1341,9 +1233,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1368,9 +1258,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -1395,9 +1283,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1422,9 +1308,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1449,9 +1333,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); + }, x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); } /// @@ -1476,9 +1358,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPageVisibleChanged += x, x => _data.IsPageVisibleChanged -= x); + }, x => _data.IsPageVisibleChanged += x, x => _data.IsPageVisibleChanged -= x); } /// @@ -1503,9 +1383,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1513,9 +1391,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); + }, x => _data.StructureChanged += x, x => _data.StructureChanged -= x); } /// @@ -1540,9 +1416,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); } /// @@ -1567,9 +1441,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1577,9 +1449,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); + }, x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); } /// @@ -1604,9 +1474,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -1631,9 +1499,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -1658,9 +1524,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); + }, x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1668,9 +1532,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1678,9 +1540,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1705,9 +1565,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1715,9 +1573,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); } /// @@ -1742,9 +1598,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1752,9 +1606,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1762,9 +1614,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1772,9 +1622,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } /// @@ -1799,9 +1647,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1826,9 +1672,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); + }, x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1836,9 +1680,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); + }, x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1846,9 +1688,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1856,9 +1696,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); + }, x => _data.ItemTapped += x, x => _data.ItemTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1866,9 +1704,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1876,9 +1712,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1886,9 +1720,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1913,9 +1745,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1940,9 +1770,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1950,9 +1778,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); } /// @@ -1977,9 +1803,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1987,9 +1811,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1997,9 +1819,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2007,9 +1827,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionRequested += x, x => _data.PositionRequested -= x); + }, x => _data.PositionRequested += x, x => _data.PositionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2017,9 +1835,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2027,9 +1843,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SeekRequested e) => eventHandler(e); return Handler; - } - - , x => _data.SeekRequested += x, x => _data.SeekRequested -= x); + }, x => _data.SeekRequested += x, x => _data.SeekRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2037,9 +1851,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.StateRequested e) => eventHandler(e); return Handler; - } - - , x => _data.StateRequested += x, x => _data.StateRequested -= x); + }, x => _data.StateRequested += x, x => _data.StateRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2047,9 +1859,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VolumeRequested += x, x => _data.VolumeRequested -= x); + }, x => _data.VolumeRequested += x, x => _data.VolumeRequested -= x); } /// @@ -2074,9 +1884,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -2101,9 +1909,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2111,9 +1917,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2121,9 +1925,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); + }, x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2131,9 +1933,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2141,9 +1941,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2151,9 +1949,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); + }, x => _data.Pushed += x, x => _data.Pushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2161,9 +1957,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2171,9 +1965,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -2198,9 +1990,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -2225,9 +2015,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2235,9 +2023,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2245,9 +2031,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -2272,9 +2056,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); + }, x => _data.PanUpdated += x, x => _data.PanUpdated -= x); } /// @@ -2299,9 +2081,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -2326,9 +2106,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); + }, x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); } /// @@ -2353,9 +2131,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -2380,9 +2156,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); } /// @@ -2407,9 +2181,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -2434,9 +2206,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2444,9 +2214,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2471,9 +2239,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); + }, x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); } /// @@ -2498,9 +2264,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2508,9 +2272,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2518,9 +2280,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2545,9 +2305,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -2572,9 +2330,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2582,9 +2338,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); } /// @@ -2609,9 +2363,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2619,9 +2371,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2629,9 +2379,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2656,9 +2404,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsActiveChanged += x, x => _data.IsActiveChanged -= x); + }, x => _data.IsActiveChanged += x, x => _data.IsActiveChanged -= x); } /// @@ -2683,9 +2429,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2710,9 +2454,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); + }, x => _data.Swiped += x, x => _data.Swiped -= x); } /// @@ -2737,9 +2479,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -2764,9 +2504,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -2791,9 +2529,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -2818,9 +2554,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2828,9 +2562,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.OpenSwipeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OpenRequested += x, x => _data.OpenRequested -= x); + }, x => _data.OpenRequested += x, x => _data.OpenRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2838,9 +2570,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); + }, x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2848,9 +2578,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeEndedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); + }, x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2858,9 +2586,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); + }, x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); } /// @@ -2885,9 +2611,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -2912,9 +2636,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); + }, x => _data.OnChanged += x, x => _data.OnChanged -= x); } /// @@ -2939,9 +2661,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -2966,9 +2686,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -2994,9 +2712,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); } /// @@ -3021,9 +2737,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3031,9 +2745,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); + }, x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3041,9 +2753,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3051,9 +2761,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3061,9 +2769,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3071,9 +2777,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3081,9 +2785,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -3108,9 +2810,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3118,9 +2818,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3128,9 +2826,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3138,9 +2834,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3148,9 +2842,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3158,9 +2850,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } } @@ -3211,9 +2901,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -3238,9 +2926,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); + }, x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); } /// @@ -3265,9 +2951,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3275,9 +2959,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -3302,9 +2984,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } } @@ -3375,9 +3055,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3402,9 +3080,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// @@ -3429,9 +3105,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OptionSelected += x, x => _data.OptionSelected -= x); + }, x => _data.OptionSelected += x, x => _data.OptionSelected -= x); } /// @@ -3456,9 +3130,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3483,9 +3155,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ControlChanged += x, x => _data.ControlChanged -= x); + }, x => _data.ControlChanged += x, x => _data.ControlChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3493,9 +3163,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ControlChanging += x, x => _data.ControlChanging -= x); + }, x => _data.ControlChanging += x, x => _data.ControlChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3503,9 +3171,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); + }, x => _data.ElementPropertyChanged += x, x => _data.ElementPropertyChanged -= x); } /// @@ -3530,9 +3196,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3557,9 +3221,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } /// @@ -3584,9 +3246,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -3611,9 +3271,7 @@ namespace Xamarin.Forms.Platform.UWP { void Handler(object sender, global::Xamarin.Forms.Platform.UWP.VisualElementChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ElementChanged += x, x => _data.ElementChanged -= x); + }, x => _data.ElementChanged += x, x => _data.ElementChanged -= x); } } @@ -3652,9 +3310,7 @@ namespace Xamarin.Forms.Platform.WinRT { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } } @@ -3697,9 +3353,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3707,9 +3361,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3717,9 +3369,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); } /// @@ -3744,9 +3394,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.BufferingProgressUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); + }, x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3754,9 +3402,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3764,9 +3410,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); + }, x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3774,9 +3418,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3784,9 +3426,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3794,9 +3434,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3804,8 +3442,6 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UpdateStreamInfo += x, x => _data.UpdateStreamInfo -= x); + }, x => _data.UpdateStreamInfo += x, x => _data.UpdateStreamInfo -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.xamarinmac20.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.xamarinios10.approved.txt similarity index 92% rename from src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.xamarinmac20.approved.txt rename to src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.xamarinios10.approved.txt index 564d875..dfb5975 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.xamarinmac20.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.xamarinios10.approved.txt @@ -340,9 +340,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); + }, x => _data.ModalPopped += x, x => _data.ModalPopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -350,9 +348,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); + }, x => _data.ModalPopping += x, x => _data.ModalPopping -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -360,9 +356,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); + }, x => _data.ModalPushed += x, x => _data.ModalPushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -370,9 +364,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); + }, x => _data.ModalPushing += x, x => _data.ModalPushing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -380,9 +372,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); + }, x => _data.PageAppearing += x, x => _data.PageAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -390,9 +380,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); + }, x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -400,9 +388,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.AppThemeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RequestedThemeChanged += x, x => _data.RequestedThemeChanged -= x); + }, x => _data.RequestedThemeChanged += x, x => _data.RequestedThemeChanged -= x); } /// @@ -427,9 +413,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -437,9 +421,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); } /// @@ -464,9 +446,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -474,9 +454,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -484,9 +462,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); + }, x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); } /// @@ -511,9 +487,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -521,9 +495,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -531,9 +503,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -558,9 +528,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -568,9 +536,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } /// @@ -595,9 +561,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -605,9 +569,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -615,9 +577,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -625,9 +585,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -652,9 +610,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -679,9 +635,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -706,9 +660,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -733,9 +685,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -760,9 +710,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// @@ -787,9 +735,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); } /// @@ -814,9 +760,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DragStartingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarting += x, x => _data.DragStarting -= x); + }, x => _data.DragStarting += x, x => _data.DragStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -824,9 +768,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DropCompletedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropCompleted += x, x => _data.DropCompleted -= x); + }, x => _data.DropCompleted += x, x => _data.DropCompleted -= x); } /// @@ -851,9 +793,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragOver += x, x => _data.DragOver -= x); + }, x => _data.DragOver += x, x => _data.DragOver -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -861,9 +801,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DropEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drop += x, x => _data.Drop -= x); + }, x => _data.Drop += x, x => _data.Drop -= x); } /// @@ -888,9 +826,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -915,9 +851,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); + }, x => _data.ChildAdded += x, x => _data.ChildAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -925,9 +859,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); + }, x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -935,9 +867,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); + }, x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -945,9 +875,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); + }, x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -956,9 +884,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -983,9 +909,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1010,9 +934,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1037,9 +959,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -1064,9 +984,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); } /// @@ -1091,9 +1009,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1119,9 +1035,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1146,9 +1060,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1173,9 +1085,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1200,9 +1110,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1227,9 +1135,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1237,9 +1143,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1247,9 +1151,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -1274,9 +1176,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); } /// @@ -1301,9 +1201,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1311,9 +1209,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1321,9 +1217,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1331,9 +1225,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1341,9 +1233,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1368,9 +1258,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -1395,9 +1283,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1422,9 +1308,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1449,9 +1333,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); + }, x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); } /// @@ -1476,9 +1358,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPageVisibleChanged += x, x => _data.IsPageVisibleChanged -= x); + }, x => _data.IsPageVisibleChanged += x, x => _data.IsPageVisibleChanged -= x); } /// @@ -1503,9 +1383,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1513,9 +1391,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); + }, x => _data.StructureChanged += x, x => _data.StructureChanged -= x); } /// @@ -1540,9 +1416,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); } /// @@ -1567,9 +1441,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1577,9 +1449,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); + }, x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); } /// @@ -1604,9 +1474,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -1631,9 +1499,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -1658,9 +1524,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); + }, x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1668,9 +1532,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1678,9 +1540,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1705,9 +1565,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1715,9 +1573,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); } /// @@ -1742,9 +1598,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1752,9 +1606,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1762,9 +1614,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1772,9 +1622,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } /// @@ -1799,9 +1647,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1826,9 +1672,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); + }, x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1836,9 +1680,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); + }, x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1846,9 +1688,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1856,9 +1696,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); + }, x => _data.ItemTapped += x, x => _data.ItemTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1866,9 +1704,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1876,9 +1712,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1886,9 +1720,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1913,9 +1745,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1940,9 +1770,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1950,9 +1778,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); } /// @@ -1977,9 +1803,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1987,9 +1811,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1997,9 +1819,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2007,9 +1827,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionRequested += x, x => _data.PositionRequested -= x); + }, x => _data.PositionRequested += x, x => _data.PositionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2017,9 +1835,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2027,9 +1843,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SeekRequested e) => eventHandler(e); return Handler; - } - - , x => _data.SeekRequested += x, x => _data.SeekRequested -= x); + }, x => _data.SeekRequested += x, x => _data.SeekRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2037,9 +1851,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.StateRequested e) => eventHandler(e); return Handler; - } - - , x => _data.StateRequested += x, x => _data.StateRequested -= x); + }, x => _data.StateRequested += x, x => _data.StateRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2047,9 +1859,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VolumeRequested += x, x => _data.VolumeRequested -= x); + }, x => _data.VolumeRequested += x, x => _data.VolumeRequested -= x); } /// @@ -2074,9 +1884,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -2101,9 +1909,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2111,9 +1917,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2121,9 +1925,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); + }, x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2131,9 +1933,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2141,9 +1941,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2151,9 +1949,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); + }, x => _data.Pushed += x, x => _data.Pushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2161,9 +1957,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2171,9 +1965,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -2198,9 +1990,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -2225,9 +2015,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2235,9 +2023,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2245,9 +2031,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -2272,9 +2056,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); + }, x => _data.PanUpdated += x, x => _data.PanUpdated -= x); } /// @@ -2299,9 +2081,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -2326,9 +2106,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); + }, x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); } /// @@ -2353,9 +2131,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -2380,9 +2156,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); } /// @@ -2407,9 +2181,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -2434,9 +2206,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2444,9 +2214,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2471,9 +2239,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); + }, x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); } /// @@ -2498,9 +2264,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2508,9 +2272,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2518,9 +2280,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2545,9 +2305,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -2572,9 +2330,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2582,9 +2338,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); } /// @@ -2609,9 +2363,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2619,9 +2371,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2629,9 +2379,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2656,9 +2404,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsActiveChanged += x, x => _data.IsActiveChanged -= x); + }, x => _data.IsActiveChanged += x, x => _data.IsActiveChanged -= x); } /// @@ -2683,9 +2429,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2710,9 +2454,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); + }, x => _data.Swiped += x, x => _data.Swiped -= x); } /// @@ -2737,9 +2479,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -2764,9 +2504,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -2791,9 +2529,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -2818,9 +2554,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2828,9 +2562,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.OpenSwipeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OpenRequested += x, x => _data.OpenRequested -= x); + }, x => _data.OpenRequested += x, x => _data.OpenRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2838,9 +2570,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); + }, x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2848,9 +2578,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeEndedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); + }, x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2858,9 +2586,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); + }, x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); } /// @@ -2885,9 +2611,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -2912,9 +2636,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); + }, x => _data.OnChanged += x, x => _data.OnChanged -= x); } /// @@ -2939,9 +2661,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -2966,9 +2686,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -2994,9 +2712,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); } /// @@ -3021,9 +2737,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3031,9 +2745,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); + }, x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3041,9 +2753,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3051,9 +2761,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3061,9 +2769,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3071,9 +2777,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3081,9 +2785,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -3108,9 +2810,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3118,9 +2818,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3128,9 +2826,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3138,9 +2834,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3148,9 +2842,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3158,9 +2850,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } } @@ -3211,9 +2901,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -3238,9 +2926,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); + }, x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); } /// @@ -3265,9 +2951,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3275,9 +2959,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -3302,9 +2984,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } } @@ -3347,9 +3027,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3357,9 +3035,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3367,9 +3043,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); } /// @@ -3394,9 +3068,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.BufferingProgressUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); + }, x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3404,9 +3076,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3414,9 +3084,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); + }, x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3424,9 +3092,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3434,9 +3100,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3444,9 +3108,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3454,8 +3116,6 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UpdateStreamInfo += x, x => _data.UpdateStreamInfo -= x); + }, x => _data.UpdateStreamInfo += x, x => _data.UpdateStreamInfo -= x); } } \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.xamarinios10.approved.txt b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.xamarinmac20.approved.txt similarity index 92% rename from src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.xamarinios10.approved.txt rename to src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.xamarinmac20.approved.txt index 84852c1..dfb5975 100644 --- a/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1560.xamarinios10.approved.txt +++ b/src/Pharmacist.Tests/IntegrationTests/Approved/Xamarin.Forms.4.8.0.1687.xamarinmac20.approved.txt @@ -340,9 +340,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopped += x, x => _data.ModalPopped -= x); + }, x => _data.ModalPopped += x, x => _data.ModalPopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -350,9 +348,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPoppingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPopping += x, x => _data.ModalPopping -= x); + }, x => _data.ModalPopping += x, x => _data.ModalPopping -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -360,9 +356,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushed += x, x => _data.ModalPushed -= x); + }, x => _data.ModalPushed += x, x => _data.ModalPushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -370,9 +364,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ModalPushingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModalPushing += x, x => _data.ModalPushing -= x); + }, x => _data.ModalPushing += x, x => _data.ModalPushing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -380,9 +372,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageAppearing += x, x => _data.PageAppearing -= x); + }, x => _data.PageAppearing += x, x => _data.PageAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -390,9 +380,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Page e) => eventHandler(e); return Handler; - } - - , x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); + }, x => _data.PageDisappearing += x, x => _data.PageDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -400,9 +388,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.AppThemeChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RequestedThemeChanged += x, x => _data.RequestedThemeChanged -= x); + }, x => _data.RequestedThemeChanged += x, x => _data.RequestedThemeChanged -= x); } /// @@ -427,9 +413,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -437,9 +421,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); } /// @@ -464,9 +446,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); + }, x => _data.BindingContextChanged += x, x => _data.BindingContextChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -474,9 +454,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -484,9 +462,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PropertyChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); + }, x => _data.PropertyChanging += x, x => _data.PropertyChanging -= x); } /// @@ -511,9 +487,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -521,9 +495,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -531,9 +503,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -558,9 +528,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CurrentItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); + }, x => _data.CurrentItemChanged += x, x => _data.CurrentItemChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -568,9 +536,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PositionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionChanged += x, x => _data.PositionChanged -= x); + }, x => _data.PositionChanged += x, x => _data.PositionChanged -= x); } /// @@ -595,9 +561,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -605,9 +569,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -615,9 +577,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -625,9 +585,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -652,9 +610,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -679,9 +635,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -706,9 +660,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -733,9 +685,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -760,9 +710,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); + }, x => _data.CanExecuteChanged += x, x => _data.CanExecuteChanged -= x); } /// @@ -787,9 +735,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DateChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DateSelected += x, x => _data.DateSelected -= x); + }, x => _data.DateSelected += x, x => _data.DateSelected -= x); } /// @@ -814,9 +760,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DragStartingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarting += x, x => _data.DragStarting -= x); + }, x => _data.DragStarting += x, x => _data.DragStarting -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -824,9 +768,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DropCompletedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DropCompleted += x, x => _data.DropCompleted -= x); + }, x => _data.DropCompleted += x, x => _data.DropCompleted -= x); } /// @@ -851,9 +793,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DragEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragOver += x, x => _data.DragOver -= x); + }, x => _data.DragOver += x, x => _data.DragOver -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -861,9 +801,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.DropEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Drop += x, x => _data.Drop -= x); + }, x => _data.Drop += x, x => _data.Drop -= x); } /// @@ -888,9 +826,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -915,9 +851,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildAdded += x, x => _data.ChildAdded -= x); + }, x => _data.ChildAdded += x, x => _data.ChildAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -925,9 +859,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); + }, x => _data.ChildRemoved += x, x => _data.ChildRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -935,9 +867,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); + }, x => _data.DescendantAdded += x, x => _data.DescendantAdded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -945,9 +875,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ElementEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); + }, x => _data.DescendantRemoved += x, x => _data.DescendantRemoved -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -956,9 +884,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -983,9 +909,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1010,9 +934,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Completed += x, x => _data.Completed -= x); + }, x => _data.Completed += x, x => _data.Completed -= x); } /// @@ -1037,9 +959,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -1064,9 +984,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); + }, x => _data.ForceUpdateSizeRequested += x, x => _data.ForceUpdateSizeRequested -= x); } /// @@ -1091,9 +1009,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -1119,9 +1035,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlatformSet += x, x => _data.PlatformSet -= x); + }, x => _data.PlatformSet += x, x => _data.PlatformSet -= x); } /// @@ -1146,9 +1060,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1173,9 +1085,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1200,9 +1110,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1227,9 +1135,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1237,9 +1143,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pressed += x, x => _data.Pressed -= x); + }, x => _data.Pressed += x, x => _data.Pressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1247,9 +1151,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Released += x, x => _data.Released -= x); + }, x => _data.Released += x, x => _data.Released -= x); } /// @@ -1274,9 +1176,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); } /// @@ -1301,9 +1201,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1311,9 +1209,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1321,9 +1217,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1331,9 +1225,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1341,9 +1233,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -1368,9 +1258,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.TextChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.TextChanged += x, x => _data.TextChanged -= x); + }, x => _data.TextChanged += x, x => _data.TextChanged -= x); } /// @@ -1395,9 +1283,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -1422,9 +1308,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1449,9 +1333,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ListProxyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); + }, x => _data.ListProxyChanged += x, x => _data.ListProxyChanged -= x); } /// @@ -1476,9 +1358,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPageVisibleChanged += x, x => _data.IsPageVisibleChanged -= x); + }, x => _data.IsPageVisibleChanged += x, x => _data.IsPageVisibleChanged -= x); } /// @@ -1503,9 +1383,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1513,9 +1391,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.StructureChanged += x, x => _data.StructureChanged -= x); + }, x => _data.StructureChanged += x, x => _data.StructureChanged -= x); } /// @@ -1540,9 +1416,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); } /// @@ -1567,9 +1441,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); + }, x => _data.ItemsCollectionChanged += x, x => _data.ItemsCollectionChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1577,9 +1449,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); + }, x => _data.NavigationRequested += x, x => _data.NavigationRequested -= x); } /// @@ -1604,9 +1474,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -1631,9 +1499,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -1658,9 +1524,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); + }, x => _data.RemainingItemsThresholdReached += x, x => _data.RemainingItemsThresholdReached -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1668,9 +1532,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemsViewScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1678,9 +1540,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1705,9 +1565,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1715,9 +1573,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); } /// @@ -1742,9 +1598,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1752,9 +1606,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1762,9 +1614,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1772,9 +1622,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } /// @@ -1799,9 +1647,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -1826,9 +1672,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); + }, x => _data.ItemAppearing += x, x => _data.ItemAppearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1836,9 +1680,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemVisibilityEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); + }, x => _data.ItemDisappearing += x, x => _data.ItemDisappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1846,9 +1688,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectedItemChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1856,9 +1696,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ItemTappedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ItemTapped += x, x => _data.ItemTapped -= x); + }, x => _data.ItemTapped += x, x => _data.ItemTapped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1866,9 +1704,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1876,9 +1712,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1886,9 +1720,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -1913,9 +1745,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -1940,9 +1770,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.BackButtonPressedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); + }, x => _data.BackButtonPressed += x, x => _data.BackButtonPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1950,9 +1778,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); + }, x => _data.IsPresentedChanged += x, x => _data.IsPresentedChanged -= x); } /// @@ -1977,9 +1803,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaEnded += x, x => _data.MediaEnded -= x); + }, x => _data.MediaEnded += x, x => _data.MediaEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1987,9 +1811,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaFailed += x, x => _data.MediaFailed -= x); + }, x => _data.MediaFailed += x, x => _data.MediaFailed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -1997,9 +1819,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MediaOpened += x, x => _data.MediaOpened -= x); + }, x => _data.MediaOpened += x, x => _data.MediaOpened -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2007,9 +1827,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PositionRequested += x, x => _data.PositionRequested -= x); + }, x => _data.PositionRequested += x, x => _data.PositionRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2017,9 +1835,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); + }, x => _data.SeekCompleted += x, x => _data.SeekCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2027,9 +1843,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SeekRequested e) => eventHandler(e); return Handler; - } - - , x => _data.SeekRequested += x, x => _data.SeekRequested -= x); + }, x => _data.SeekRequested += x, x => _data.SeekRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2037,9 +1851,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.StateRequested e) => eventHandler(e); return Handler; - } - - , x => _data.StateRequested += x, x => _data.StateRequested -= x); + }, x => _data.StateRequested += x, x => _data.StateRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2047,9 +1859,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.VolumeRequested += x, x => _data.VolumeRequested -= x); + }, x => _data.VolumeRequested += x, x => _data.VolumeRequested -= x); } /// @@ -2074,9 +1884,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Clicked += x, x => _data.Clicked -= x); + }, x => _data.Clicked += x, x => _data.Clicked -= x); } /// @@ -2101,9 +1909,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); + }, x => _data.InsertPageBeforeRequested += x, x => _data.InsertPageBeforeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2111,9 +1917,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Popped += x, x => _data.Popped -= x); + }, x => _data.Popped += x, x => _data.Popped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2121,9 +1925,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); + }, x => _data.PoppedToRoot += x, x => _data.PoppedToRoot -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2131,9 +1933,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopRequested += x, x => _data.PopRequested -= x); + }, x => _data.PopRequested += x, x => _data.PopRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2141,9 +1941,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); + }, x => _data.PopToRootRequested += x, x => _data.PopToRootRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2151,9 +1949,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.NavigationEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Pushed += x, x => _data.Pushed -= x); + }, x => _data.Pushed += x, x => _data.Pushed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2161,9 +1957,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PushRequested += x, x => _data.PushRequested -= x); + }, x => _data.PushRequested += x, x => _data.PushRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2171,9 +1965,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.NavigationRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); + }, x => _data.RemovePageRequested += x, x => _data.RemovePageRequested -= x); } /// @@ -2198,9 +1990,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); + }, x => _data.DisplayRequested += x, x => _data.DisplayRequested -= x); } /// @@ -2225,9 +2015,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Appearing += x, x => _data.Appearing -= x); + }, x => _data.Appearing += x, x => _data.Appearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2235,9 +2023,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Disappearing += x, x => _data.Disappearing -= x); + }, x => _data.Disappearing += x, x => _data.Disappearing -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2245,9 +2031,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); + }, x => _data.LayoutChanged += x, x => _data.LayoutChanged -= x); } /// @@ -2272,9 +2056,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PanUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PanUpdated += x, x => _data.PanUpdated -= x); + }, x => _data.PanUpdated += x, x => _data.PanUpdated -= x); } /// @@ -2299,9 +2081,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); + }, x => _data.SelectedIndexChanged += x, x => _data.SelectedIndexChanged -= x); } /// @@ -2326,9 +2106,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.PinchGestureUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); + }, x => _data.PinchUpdated += x, x => _data.PinchUpdated -= x); } /// @@ -2353,9 +2131,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.CheckedChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); + }, x => _data.CheckedChanged += x, x => _data.CheckedChanged -= x); } /// @@ -2380,9 +2156,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Refreshing += x, x => _data.Refreshing -= x); + }, x => _data.Refreshing += x, x => _data.Refreshing -= x); } /// @@ -2407,9 +2181,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); } /// @@ -2434,9 +2206,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrolledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Scrolled += x, x => _data.Scrolled -= x); + }, x => _data.Scrolled += x, x => _data.Scrolled -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2444,9 +2214,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ScrollToRequestedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); + }, x => _data.ScrollToRequested += x, x => _data.ScrollToRequested -= x); } /// @@ -2471,9 +2239,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); + }, x => _data.SearchButtonPressed += x, x => _data.SearchButtonPressed -= x); } /// @@ -2498,9 +2264,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2508,9 +2272,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2518,9 +2280,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -2545,9 +2305,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SelectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); + }, x => _data.SelectionChanged += x, x => _data.SelectionChanged -= x); } /// @@ -2572,9 +2330,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2582,9 +2338,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ShellNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); } /// @@ -2609,9 +2363,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragCompleted += x, x => _data.DragCompleted -= x); + }, x => _data.DragCompleted += x, x => _data.DragCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2619,9 +2371,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.DragStarted += x, x => _data.DragStarted -= x); + }, x => _data.DragStarted += x, x => _data.DragStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2629,9 +2379,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2656,9 +2404,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.IsActiveChanged += x, x => _data.IsActiveChanged -= x); + }, x => _data.IsActiveChanged += x, x => _data.IsActiveChanged -= x); } /// @@ -2683,9 +2429,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ValueChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValueChanged += x, x => _data.ValueChanged -= x); + }, x => _data.ValueChanged += x, x => _data.ValueChanged -= x); } /// @@ -2710,9 +2454,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Swiped += x, x => _data.Swiped -= x); + }, x => _data.Swiped += x, x => _data.Swiped -= x); } /// @@ -2737,9 +2479,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -2764,9 +2504,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } /// @@ -2791,9 +2529,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Invoked += x, x => _data.Invoked -= x); + }, x => _data.Invoked += x, x => _data.Invoked -= x); } /// @@ -2818,9 +2554,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CloseRequested += x, x => _data.CloseRequested -= x); + }, x => _data.CloseRequested += x, x => _data.CloseRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2828,9 +2562,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.OpenSwipeEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OpenRequested += x, x => _data.OpenRequested -= x); + }, x => _data.OpenRequested += x, x => _data.OpenRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2838,9 +2570,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeChangingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); + }, x => _data.SwipeChanging += x, x => _data.SwipeChanging -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2848,9 +2578,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeEndedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); + }, x => _data.SwipeEnded += x, x => _data.SwipeEnded -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -2858,9 +2586,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.SwipeStartedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); + }, x => _data.SwipeStarted += x, x => _data.SwipeStarted -= x); } /// @@ -2885,9 +2611,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Toggled += x, x => _data.Toggled -= x); + }, x => _data.Toggled += x, x => _data.Toggled -= x); } /// @@ -2912,9 +2636,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.ToggledEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.OnChanged += x, x => _data.OnChanged -= x); + }, x => _data.OnChanged += x, x => _data.OnChanged -= x); } /// @@ -2939,9 +2661,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ModelChanged += x, x => _data.ModelChanged -= x); + }, x => _data.ModelChanged += x, x => _data.ModelChanged -= x); } /// @@ -2966,9 +2686,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Tapped += x, x => _data.Tapped -= x); + }, x => _data.Tapped += x, x => _data.Tapped -= x); } /// @@ -2994,9 +2712,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Activated += x, x => _data.Activated -= x); + }, x => _data.Activated += x, x => _data.Activated -= x); } /// @@ -3021,9 +2737,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); + }, x => _data.BatchCommitted += x, x => _data.BatchCommitted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3031,9 +2745,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); + }, x => _data.ChildrenReordered += x, x => _data.ChildrenReordered -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3041,9 +2753,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.VisualElement.FocusRequestArgs e) => eventHandler(e); return Handler; - } - - , x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); + }, x => _data.FocusChangeRequested += x, x => _data.FocusChangeRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3051,9 +2761,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Focused += x, x => _data.Focused -= x); + }, x => _data.Focused += x, x => _data.Focused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3061,9 +2769,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); + }, x => _data.MeasureInvalidated += x, x => _data.MeasureInvalidated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3071,9 +2777,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.SizeChanged += x, x => _data.SizeChanged -= x); + }, x => _data.SizeChanged += x, x => _data.SizeChanged -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3081,9 +2785,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.FocusEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Unfocused += x, x => _data.Unfocused -= x); + }, x => _data.Unfocused += x, x => _data.Unfocused -= x); } /// @@ -3108,9 +2810,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.Internals.EvalRequested e) => eventHandler(e); return Handler; - } - - , x => _data.EvalRequested += x, x => _data.EvalRequested -= x); + }, x => _data.EvalRequested += x, x => _data.EvalRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3118,9 +2818,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); + }, x => _data.GoBackRequested += x, x => _data.GoBackRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3128,9 +2826,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); + }, x => _data.GoForwardRequested += x, x => _data.GoForwardRequested -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3138,9 +2834,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigated += x, x => _data.Navigated -= x); + }, x => _data.Navigated += x, x => _data.Navigated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3148,9 +2842,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::Xamarin.Forms.WebNavigatingEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.Navigating += x, x => _data.Navigating -= x); + }, x => _data.Navigating += x, x => _data.Navigating -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3158,9 +2850,7 @@ namespace Xamarin.Forms { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); + }, x => _data.ReloadRequested += x, x => _data.ReloadRequested -= x); } } @@ -3211,9 +2901,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.ComponentModel.PropertyChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); + }, x => _data.PropertyChanged += x, x => _data.PropertyChanged -= x); } /// @@ -3238,9 +2926,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.ResourcesChangedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); + }, x => _data.ValuesChanged += x, x => _data.ValuesChanged -= x); } /// @@ -3265,9 +2951,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); + }, x => _data.ItemLongPressed += x, x => _data.ItemLongPressed -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3275,9 +2959,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::Xamarin.Forms.Internals.EventArg e) => eventHandler(e); return Handler; - } - - , x => _data.ItemSelected += x, x => _data.ItemSelected -= x); + }, x => _data.ItemSelected += x, x => _data.ItemSelected -= x); } /// @@ -3302,9 +2984,7 @@ namespace Xamarin.Forms.Internals { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); + }, x => _data.CollectionChanged += x, x => _data.CollectionChanged -= x); } } @@ -3347,9 +3027,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3357,9 +3035,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3367,9 +3043,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); } /// @@ -3394,9 +3068,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::Xamarin.Forms.PlatformConfiguration.TizenSpecific.BufferingProgressUpdatedEventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); + }, x => _data.BufferingProgressUpdated += x, x => _data.BufferingProgressUpdated -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3404,9 +3076,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); + }, x => _data.ErrorOccurred += x, x => _data.ErrorOccurred -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3414,9 +3084,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); + }, x => _data.PlaybackCompleted += x, x => _data.PlaybackCompleted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3424,9 +3092,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); + }, x => _data.PlaybackPaused += x, x => _data.PlaybackPaused -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3434,9 +3100,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); + }, x => _data.PlaybackStarted += x, x => _data.PlaybackStarted -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3444,9 +3108,7 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); + }, x => _data.PlaybackStopped += x, x => _data.PlaybackStopped -= x); /// /// Gets an observable which signals when the event triggers. /// @@ -3454,8 +3116,6 @@ namespace Xamarin.Forms.PlatformConfiguration.TizenSpecific { void Handler(object sender, global::System.EventArgs e) => eventHandler(e); return Handler; - } - - , x => _data.UpdateStreamInfo += x, x => _data.UpdateStreamInfo -= x); + }, x => _data.UpdateStreamInfo += x, x => _data.UpdateStreamInfo -= x); } -} +} \ No newline at end of file diff --git a/src/Pharmacist.Tests/IntegrationTests/IntegrationTestHelper.cs b/src/Pharmacist.Tests/IntegrationTests/IntegrationTestHelper.cs index f3ba988..a483e1c 100644 --- a/src/Pharmacist.Tests/IntegrationTests/IntegrationTestHelper.cs +++ b/src/Pharmacist.Tests/IntegrationTests/IntegrationTestHelper.cs @@ -32,15 +32,13 @@ internal static class IntegrationTestHelper public static async Task CheckResultsAgainstTemplate(PackageIdentity[] package, IReadOnlyList frameworks, [CallerFilePath]string filePath = null, [CallerMemberName]string memberName = null) { - using (var memoryStream = new MemoryStream()) + using var memoryStream = new MemoryStream(); + using (var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8, 1024, true)) { - using (var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8, 1024, true)) - { - await ObservablesForEventGenerator.ExtractEventsFromNuGetPackages(streamWriter, package, frameworks, TestUtilities.GetPackageDirectory(memberName, filePath)).ConfigureAwait(false); - } - - CheckPackageIdentityContents(memoryStream, package[0], frameworks[0], filePath); + await ObservablesForEventGenerator.ExtractEventsFromNuGetPackages(streamWriter, package, frameworks, TestUtilities.GetPackageDirectory(memberName, filePath)).ConfigureAwait(false); } + + CheckPackageIdentityContents(memoryStream, package[0], frameworks[0], filePath); } public static async Task CheckResultsAgainstTemplate(LibraryRange[] package, IReadOnlyList frameworks, [CallerFilePath]string filePath = null, [CallerMemberName]string memberName = null) @@ -49,15 +47,13 @@ public static async Task CheckResultsAgainstTemplate(LibraryRange[] package, IRe var findResource = await sourceRepository.GetResourceAsync().ConfigureAwait(false); var bestPackageIdentity = await NuGetPackageHelper.GetBestMatch(package[0], findResource, CancellationToken.None).ConfigureAwait(false); - using (var memoryStream = new MemoryStream()) + using var memoryStream = new MemoryStream(); + using (var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8, 1024, true)) { - using (var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8, 1024, true)) - { - await ObservablesForEventGenerator.ExtractEventsFromNuGetPackages(streamWriter, package, frameworks, TestUtilities.GetPackageDirectory(memberName, filePath)).ConfigureAwait(false); - } - - CheckPackageIdentityContents(memoryStream, bestPackageIdentity, frameworks[0], filePath); + await ObservablesForEventGenerator.ExtractEventsFromNuGetPackages(streamWriter, package, frameworks, TestUtilities.GetPackageDirectory(memberName, filePath)).ConfigureAwait(false); } + + CheckPackageIdentityContents(memoryStream, bestPackageIdentity, frameworks[0], filePath); } public static void CheckContents(string actualContents, string approvedFileName, string receivedFileName) @@ -138,10 +134,10 @@ private static void CheckPackageIdentityContents(MemoryStream memoryStream, Pack memoryStream.Flush(); memoryStream.Position = 0; - using (var sr = new StreamReader(memoryStream)) - { - CheckContents(sr.ReadToEnd().Trim('\n').Trim('\r'), approvedFileName, receivedFileName); - } + using var sr = new StreamReader(memoryStream); + + var contents = sr.ReadToEnd(); + CheckContents(contents.Trim('\n').Trim('\r'), approvedFileName, receivedFileName); } } } diff --git a/src/Pharmacist.Tests/IntegrationTests/LibraryRangeNugetTest.cs b/src/Pharmacist.Tests/IntegrationTests/LibraryRangeNugetTest.cs index cc1bca0..10d50f7 100644 --- a/src/Pharmacist.Tests/IntegrationTests/LibraryRangeNugetTest.cs +++ b/src/Pharmacist.Tests/IntegrationTests/LibraryRangeNugetTest.cs @@ -17,7 +17,7 @@ namespace Pharmacist.Tests.IntegrationTests public class LibraryRangeNuGetTest { [Theory] - [InlineData("Xamarin.Forms", "4.*", "MonoAndroid81")] + [InlineData("Xamarin.Forms", "4.*", "MonoAndroid10.0")] [InlineData("Xamarin.Forms", "4.*", "MonoAndroid90")] [InlineData("Xamarin.Forms", "4.*", "tizen40")] [InlineData("Xamarin.Forms", "4.*", "uap10.0.17763")] @@ -32,16 +32,17 @@ public class LibraryRangeNuGetTest [InlineData("Xamarin.Essentials", "1.*", "netstandard2.0")] [InlineData("Tizen.NET.API4", "4.*", "netstandard2.0")] [InlineData("Avalonia", "0.9.*", "netstandard2.0")] - [InlineData("Avalonia", "0.9.*", "netcoreapp2.0")] - [InlineData("Avalonia", "0.9.*", "net461")] + [InlineData("Avalonia", "0.9.*", "net5.0")] + [InlineData("Avalonia", "0.9.*", "net472")] [InlineData("Avalonia.Remote.Protocol", "0.9.*", "netstandard2.0")] [InlineData("Uno.UI", "1.44.*", "netstandard2.0")] [InlineData("Uno.UI", "1.44.*", "MonoAndroid80")] [InlineData("Uno.UI", "1.44.*", "MonoAndroid90")] [InlineData("Uno.UI", "1.44.*", "Xamarin.iOS10")] [InlineData("Uno.Core", "1.27.*", "netstandard2.0")] - [InlineData("Uno.Core", "1.27.*", "net461")] + [InlineData("Uno.Core", "1.27.*", "net472")] [InlineData("Uno.Core", "1.27.*", "uap10.0.17763")] + [InlineData("Uno.Core", "1.27.*", "net5.0")] public Task ProcessLibraryRange(string packageName, string nugetVersion, string framework) { var package = new[] { new LibraryRange(packageName, VersionRange.Parse(nugetVersion), LibraryDependencyTarget.Package) }; diff --git a/src/Pharmacist.Tests/IntegrationTests/PackageIdentityNuGetTest.cs b/src/Pharmacist.Tests/IntegrationTests/PackageIdentityNuGetTest.cs index abb2000..2be2f0b 100644 --- a/src/Pharmacist.Tests/IntegrationTests/PackageIdentityNuGetTest.cs +++ b/src/Pharmacist.Tests/IntegrationTests/PackageIdentityNuGetTest.cs @@ -19,14 +19,14 @@ namespace Pharmacist.Tests.IntegrationTests public class PackageIdentityNuGetTest { [Theory] - [InlineData("Xamarin.Forms", "4.3.0.991250", "MonoAndroid81")] + [InlineData("Xamarin.Forms", "4.3.0.991250", "MonoAndroid10.0")] [InlineData("Xamarin.Forms", "4.3.0.991250", "MonoAndroid90")] [InlineData("Xamarin.Forms", "4.3.0.991250", "tizen40")] [InlineData("Xamarin.Forms", "4.3.0.991250", "uap10.0.17763")] [InlineData("Xamarin.Forms", "4.3.0.991250", "Xamarin.iOS10")] [InlineData("Xamarin.Forms", "4.3.0.991250", "Xamarin.Mac20")] [InlineData("Xamarin.Forms", "4.3.0.991250", "netstandard2.0")] - [InlineData("Xamarin.Essentials", "1.0.0", "MonoAndroid81")] + [InlineData("Xamarin.Essentials", "1.0.0", "MonoAndroid10.0")] [InlineData("Xamarin.Essentials", "1.0.0", "MonoAndroid90")] [InlineData("Xamarin.Essentials", "1.0.0", "uap10.0.17763")] [InlineData("Xamarin.Essentials", "1.0.0", "Xamarin.iOS10")] @@ -34,16 +34,19 @@ public class PackageIdentityNuGetTest [InlineData("Xamarin.Essentials", "1.0.0", "netstandard2.0")] [InlineData("Tizen.NET.API4", "4.0.1.14152 ", "netstandard2.0")] [InlineData("Avalonia", "0.9.12", "netstandard2.0")] - [InlineData("Avalonia", "0.9.12", "netcoreapp2.0")] - [InlineData("Avalonia", "0.9.12", "net461")] + [InlineData("Avalonia", "0.9.12", "netcoreapp3.1")] + [InlineData("Avalonia", "0.9.12", "net5.0")] + [InlineData("Avalonia", "0.9.12", "net472")] [InlineData("Avalonia.Remote.Protocol", "0.9.12", "netstandard2.0")] [InlineData("Uno.UI", "1.44.1", "netstandard2.0")] [InlineData("Uno.UI", "1.44.1", "MonoAndroid80")] [InlineData("Uno.UI", "1.44.1", "MonoAndroid90")] [InlineData("Uno.UI", "1.44.1", "Xamarin.iOS10")] + [InlineData("Uno.UI", "1.44.1", "net5.0")] [InlineData("Uno.Core", "1.27.0", "netstandard2.0")] - [InlineData("Uno.Core", "1.27.0", "net461")] + [InlineData("Uno.Core", "1.27.0", "net472")] [InlineData("Uno.Core", "1.27.0", "uap10.0.17763")] + [InlineData("Uno.Core", "1.27.0", "net5.0")] public Task ProcessPackageIdentity(string packageName, string nugetVersion, string frameworkString) { var package = new[] { new PackageIdentity(packageName, new NuGetVersion(nugetVersion)) }; diff --git a/src/Pharmacist.Tests/IntegrationTests/PlatformsIntegrationTests.cs b/src/Pharmacist.Tests/IntegrationTests/PlatformsIntegrationTests.cs index 408c9e1..0693522 100644 --- a/src/Pharmacist.Tests/IntegrationTests/PlatformsIntegrationTests.cs +++ b/src/Pharmacist.Tests/IntegrationTests/PlatformsIntegrationTests.cs @@ -3,6 +3,10 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for full license information. +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; using System.Threading.Tasks; using Pharmacist.Core; @@ -17,25 +21,86 @@ namespace Pharmacist.Tests.IntegrationTests /// public class PlatformsIntegrationTests { + private static IEnumerable Frameworks { get; } = new string[] + { + "Xamarin.Mac20", + "net471", + "net472", + "net48", + "net461", + "net462", + "netcoreapp3.0", + "netcoreapp3.1", + "net5.0", + "Xamarin.WATCHOS10", + "Xamarin.iOS10", + "uap10.0.16299", + "uap10.0.17763", + "uap10.0.19041" + }; + + /// + /// The tests to perform. + /// + /// The test data. + public static IEnumerable GetPlatforms() + { + foreach (var platform in Frameworks.Where(x => x.StartsWith("net", StringComparison.OrdinalIgnoreCase))) + { + yield return new object[] { platform, true, true }; + yield return new object[] { platform, false, true }; + yield return new object[] { platform, true, false }; + } + + foreach (var platform in Frameworks.Where(x => !x.StartsWith("net", StringComparison.OrdinalIgnoreCase))) + { + yield return new object[] { platform, false, false }; + } + } + /// /// Tests to make sure that the platform tests produce valid output. /// - /// The platform to test. + /// The platform to test. + /// If to generate WPF. + /// If to generate WinForms. /// A task to monitor the progress. [Theory] - [InlineData(AutoPlatform.Winforms)] - [InlineData(AutoPlatform.Android)] - [InlineData(AutoPlatform.Mac)] - [InlineData(AutoPlatform.TVOS)] - [InlineData(AutoPlatform.UWP, Skip = "Failing")] - [InlineData(AutoPlatform.WPF)] - [InlineData(AutoPlatform.iOS)] - public async Task PlatformGeneratesCode(AutoPlatform autoPlatform) + [MemberData(nameof(GetPlatforms))] + public async Task PlatformGeneratesCode(string platform, bool isWpf, bool isWinforms) { - var sourceDirectory = IntegrationTestHelper.GetOutputDirectory(); + if (platform == null) + { + throw new ArgumentNullException(nameof(platform)); + } + + var sourceDirectory = Path.Combine(IntegrationTestHelper.GetOutputDirectory(), "Platforms"); + + if (!Directory.Exists(sourceDirectory)) + { + Directory.CreateDirectory(sourceDirectory); + } + var referenceAssembliesLocation = ReferenceLocator.GetReferenceLocation(); - await ObservablesForEventGenerator.ExtractEventsFromPlatforms(sourceDirectory, string.Empty, ".received.txt", referenceAssembliesLocation, new[] { autoPlatform }, TestUtilities.GetPackageDirectory()).ConfigureAwait(false); + var nameSuffix = string.Empty; + + if (isWpf) + { + nameSuffix += ".wpf"; + } + + if (isWinforms) + { + nameSuffix += ".winforms"; + } + + var receivedSuffix = nameSuffix + ".received.txt"; + var receivedFileName = Path.Combine(sourceDirectory, platform.ToLowerInvariant() + receivedSuffix); + var approvedSuffix = nameSuffix + ".approved.txt"; + var approvedFileName = Path.Combine(sourceDirectory, platform.ToLowerInvariant() + approvedSuffix); + + await ObservablesForEventGenerator.ExtractEventsFromPlatforms(sourceDirectory, string.Empty, receivedSuffix, referenceAssembliesLocation, platform, isWpf, isWinforms, TestUtilities.GetPackageDirectory(), false).ConfigureAwait(false); } } } diff --git a/src/Pharmacist.Tests/NuGetPackageHelperTests.cs b/src/Pharmacist.Tests/NuGetPackageHelperTests.cs index 07dd3b6..9cf9f0d 100644 --- a/src/Pharmacist.Tests/NuGetPackageHelperTests.cs +++ b/src/Pharmacist.Tests/NuGetPackageHelperTests.cs @@ -142,7 +142,7 @@ public async Task CanGetNuGetProtocolAndDependencies() var includeFiles = result.IncludeGroup.GetAllFileNames().ToList(); includeFiles.Should().NotBeEmpty(); - includeFiles.Where(x => x.EndsWith(".dll")).Should().NotBeEmpty(); + includeFiles.Where(x => x.EndsWith(".dll", StringComparison.InvariantCultureIgnoreCase)).Should().NotBeEmpty(); } [Fact] @@ -157,13 +157,13 @@ public async Task CanGetNetCoreApp20() var includeFiles = result.IncludeGroup.GetAllFileNames().ToList(); includeFiles.Should().NotBeEmpty(); - includeFiles.Where(x => x.EndsWith(".dll")).Should().NotBeEmpty(); + includeFiles.Where(x => x.EndsWith(".dll", StringComparison.InvariantCultureIgnoreCase)).Should().NotBeEmpty(); } [Fact] public async Task CanGetNetFramework() { - var package = new[] { new PackageIdentity("Microsoft.NETFramework.ReferenceAssemblies.net461", new NuGetVersion("1.0.0-preview.2")) }; + var package = new[] { new PackageIdentity("Microsoft.NETFramework.ReferenceAssemblies.net472", new NuGetVersion("1.0.0-preview.2")) }; var frameworks = new[] { FrameworkConstants.CommonFrameworks.Net461 }; @@ -173,7 +173,7 @@ public async Task CanGetNetFramework() var includeFiles = result.IncludeGroup.GetAllFileNames().ToList(); includeFiles.Should().NotBeEmpty(); - includeFiles.Where(x => x.EndsWith(".dll")).Should().NotBeEmpty(); + includeFiles.Where(x => x.EndsWith(".dll", StringComparison.InvariantCultureIgnoreCase)).Should().NotBeEmpty(); } private static async Task GetAndCheckTizenPackage() diff --git a/src/Pharmacist.Tests/Pharmacist.Tests.csproj b/src/Pharmacist.Tests/Pharmacist.Tests.csproj index 679cb17..fcb7c90 100644 --- a/src/Pharmacist.Tests/Pharmacist.Tests.csproj +++ b/src/Pharmacist.Tests/Pharmacist.Tests.csproj @@ -1,7 +1,7 @@  - netcoreapp3.1 + netcoreapp3.1;net5.0 false $(NoWarn);1591;SA1633;SA1600;CA1307 false @@ -19,20 +19,17 @@ - + - - all - runtime; build; native; contentfiles; analyzers - - + - + - + + @@ -41,4 +38,10 @@ PreserveNewest + + + + + + diff --git a/src/Pharmacist.Tests/xunit.runner.json b/src/Pharmacist.Tests/xunit.runner.json index 43b8f49..3c0042e 100644 --- a/src/Pharmacist.Tests/xunit.runner.json +++ b/src/Pharmacist.Tests/xunit.runner.json @@ -1,4 +1,5 @@ { "$schema": "https://xunit.github.io/schema/current/xunit.runner.schema.json", - "shadowCopy": false + "shadowCopy": false, + "diagnosticMessages": true } diff --git a/src/Pharmacist.sln b/src/Pharmacist.sln index bfd5aaf..d1a6142 100644 --- a/src/Pharmacist.sln +++ b/src/Pharmacist.sln @@ -21,8 +21,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution global.json = global.json stylecop.json = stylecop.json ..\version.json = ..\version.json - ..\build.cake = ..\build.cake - ..\build.config = ..\build.config EndProjectSection EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Pharmacist.IntegrationTest", "Pharmacist.IntegrationTest\Pharmacist.IntegrationTest.csproj", "{57BD0D2F-A8E3-4854-BD76-3570E7C56154}" @@ -35,7 +33,9 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{8B77401B-FFC EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{7674B335-ED10-4C0D-9727-52406743B083}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Pharmacist.MsBuild.TargetFramework", "Pharmacist.MsBuild.TargetFramework\Pharmacist.MsBuild.TargetFramework.csproj", "{D353B43D-324F-4E97-BAA6-F8D0F8C1DB30}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Pharmacist.MsBuild.TargetFramework", "Pharmacist.MsBuild.TargetFramework\Pharmacist.MsBuild.TargetFramework.csproj", "{D353B43D-324F-4E97-BAA6-F8D0F8C1DB30}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ICSharpCode.Decompiler", "ICSharpCode.Decompiler\ICSharpCode.Decompiler.csproj", "{B931CBB6-C399-447A-B1EC-87AFB45AAE11}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -75,6 +75,10 @@ Global {D353B43D-324F-4E97-BAA6-F8D0F8C1DB30}.Debug|Any CPU.Build.0 = Debug|Any CPU {D353B43D-324F-4E97-BAA6-F8D0F8C1DB30}.Release|Any CPU.ActiveCfg = Release|Any CPU {D353B43D-324F-4E97-BAA6-F8D0F8C1DB30}.Release|Any CPU.Build.0 = Release|Any CPU + {B931CBB6-C399-447A-B1EC-87AFB45AAE11}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B931CBB6-C399-447A-B1EC-87AFB45AAE11}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B931CBB6-C399-447A-B1EC-87AFB45AAE11}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B931CBB6-C399-447A-B1EC-87AFB45AAE11}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -87,6 +91,7 @@ Global {2714A571-3FA9-4F27-9E62-EB722A00AC53} = {8B77401B-FFCE-4AB0-8D3B-6A550783B835} {C7C48470-B72E-454B-BB53-E48BB6F7DAD7} = {8B77401B-FFCE-4AB0-8D3B-6A550783B835} {D353B43D-324F-4E97-BAA6-F8D0F8C1DB30} = {8B77401B-FFCE-4AB0-8D3B-6A550783B835} + {B931CBB6-C399-447A-B1EC-87AFB45AAE11} = {8B77401B-FFCE-4AB0-8D3B-6A550783B835} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {8AD09057-1163-45D2-A260-CB034E6DFD07} diff --git a/src/stylecop.json b/src/stylecop.json index 66c88ad..1a0d190 100644 --- a/src/stylecop.json +++ b/src/stylecop.json @@ -13,7 +13,7 @@ "documentPrivateFields": false, "documentationCulture": "en-US", "companyName": ".NET Foundation and Contributors", - "copyrightText": "Copyright (c) 2019 {companyName}. All rights reserved.\nLicensed to the .NET Foundation under one or more agreements.\nThe .NET Foundation licenses this file to you under the {licenseName} license.\nSee the {licenseFile} file in the project root for full license information.", + "copyrightText": "Copyright (c) 2019-2020 {companyName}. All rights reserved.\nLicensed to the .NET Foundation under one or more agreements.\nThe .NET Foundation licenses this file to you under the {licenseName} license.\nSee the {licenseFile} file in the project root for full license information.", "variables": { "licenseName": "MIT", "licenseFile": "LICENSE" @@ -36,6 +36,6 @@ "orderingRules": { "usingDirectivesPlacement": "outsideNamespace", "systemUsingDirectivesFirst": true - }, + } } }